private SqlDocumentRepository ConfigureDocumentRepository()
{
var documentRepository = new SqlDocumentRepository(_infrastructureFactory.CreateParser(), _infrastructureFactory.CreateStatementValidator(), _infrastructureFactory.CreateDatabaseModel(ConfigurationProvider.ConnectionStrings[0], "Test database model"));
documentRepository.UpdateStatements(_editor.Text);
return(documentRepository);
}
internal ICollection <ContextAction> GetContextActions(OracleDatabaseModelBase databaseModel, string statementText, int cursorPosition)
{
var documentStore = new SqlDocumentRepository(OracleSqlParser.Instance, new OracleStatementValidator(), databaseModel, statementText);
var executionContext = new ActionExecutionContext(statementText, cursorPosition, cursorPosition, 0, documentStore);
return(GetContextActions(documentStore, executionContext));
}
public void Initialize(IInfrastructureFactory infrastructureFactory, IDatabaseModel databaseModel)
{
_helpProvider = infrastructureFactory.CreateHelpProvider();
_codeCompletionProvider = infrastructureFactory.CreateCodeCompletionProvider();
_navigationService = infrastructureFactory.CreateNavigationService();
_colorizingTransformer.SetParser(infrastructureFactory.CreateParser());
DocumentRepository = new SqlDocumentRepository(infrastructureFactory.CreateParser(), infrastructureFactory.CreateStatementValidator(), databaseModel);
}
public ActionExecutionContext(string statementText, int caretOffset, int selectionStart, int selectionLength, SqlDocumentRepository documentRepository)
{
StatementText = statementText;
SelectedSegments = new[] { SourcePosition.Create(selectionStart, selectionLength) };
SelectionStart = selectionStart;
SelectionLength = selectionLength;
CaretOffset = caretOffset;
DocumentRepository = documentRepository;
}
public ActionExecutionContext(string statementText, int caretOffset, int selectionStart, int selectionLength, SqlDocumentRepository documentRepository)
{
StatementText = statementText;
SelectedSegments = new[] { SourcePosition.Create(selectionStart, selectionLength) };
SelectionStart = selectionStart;
SelectionLength = selectionLength;
CaretOffset = caretOffset;
DocumentRepository = documentRepository;
}
public DocumentService(
AzureBlobStorage blobStorage,
SqlDocumentRepository documentRepository,
Settings settings)
{
_blobStorage = blobStorage;
_documentRepository = documentRepository;
_settings = settings;
}
public static ActionExecutionContext Create(TextEditor editor, SqlDocumentRepository documentRepository)
{
return
(new ActionExecutionContext(editor.Text, editor.CaretOffset, editor.SelectionStart, editor.SelectionLength, documentRepository)
{
SelectedSegments = editor.TextArea.Selection.Segments
.Select(s => SourcePosition.Create(s.StartOffset, s.EndOffset - 1))
.ToArray()
});
}
public static ActionExecutionContext Create(TextEditor editor, SqlDocumentRepository documentRepository)
{
return
new ActionExecutionContext(editor.Text, editor.CaretOffset, editor.SelectionStart, editor.SelectionLength, documentRepository)
{
SelectedSegments = editor.TextArea.Selection.Segments
.Select(s => SourcePosition.Create(s.StartOffset, s.EndOffset - 1))
.ToArray()
};
}
public void TestNavigateToColumnDefinitionWhenDatabaseModelNotLoaded()
{
const string query = "SELECT P.PROJECT_ID, P.NAME FROM (SELECT * FROM PROJECT) P";
var databaseModel = new OracleTestDatabaseModel();
databaseModel.AllObjects.Clear();
var documentRepository = new SqlDocumentRepository(OracleSqlParser.Instance, new OracleStatementValidator(), databaseModel);
documentRepository.UpdateStatements(query);
const int caretOffset = 13;
var executionContext = new ActionExecutionContext(query, caretOffset, caretOffset, caretOffset, documentRepository);
var targetIndex = _navigationService.NavigateToDefinition(executionContext);
targetIndex.ShouldBe(null);
}
public static void ExecuteEditCommand(SqlDocumentRepository documentRepository, SqlTextEditor editor, Action <ActionExecutionContext> executionHandler)
{
if (editor.IsReadOnly || !String.Equals(documentRepository.StatementText, editor.Text))
{
return;
}
var executionContext = ActionExecutionContext.Create(editor, documentRepository);
try
{
executionHandler(executionContext);
UpdateDocument(editor, executionContext);
}
catch (Exception exception)
{
App.LogErrorAndShowMessage(exception);
}
}
public IEnumerable <ICodeSnippet> GetSnippets(SqlDocumentRepository sqlDocumentRepository, string statementText, int cursorPosition)
{
if (sqlDocumentRepository?.Statements == null)
{
return(EmptyCollection);
}
var statement = sqlDocumentRepository.Statements.TakeWhile(s => s.SourcePosition.IndexStart <= cursorPosition - 1).LastOrDefault();
StatementGrammarNode currentNode = null;
if (statement != null)
{
currentNode =
statement.GetTerminalAtPosition(cursorPosition)
?? statement.GetNearestTerminalToPosition(cursorPosition);
}
if (currentNode != null &&
String.Equals(currentNode.Id, OracleGrammarDescription.Terminals.RightParenthesis) &&
!String.Equals(currentNode.ParentNode.Id, OracleGrammarDescription.NonTerminals.CommonTableExpression) &&
currentNode.PrecedingTerminal?.PrecedingTerminal != null)
{
currentNode = currentNode.PrecedingTerminal.PrecedingTerminal;
}
var textToReplace = new String(statementText.Substring(0, cursorPosition).Reverse().TakeWhile(c => !c.In(' ', '\n', '\t', '(', '\r', ';')).Reverse().ToArray());
if (String.IsNullOrWhiteSpace(textToReplace))
{
return(EmptyCollection);
}
var candidates = OracleSqlParser.Instance.GetTerminalCandidates(currentNode).Select(c => c.Id);
return(Snippets.SnippetCollection.Where(s => s.Name.ToUpperInvariant().Contains(textToReplace.ToUpperInvariant()) &&
(s.AllowedTerminals == null || s.AllowedTerminals.Length == 0 || s.AllowedTerminals.Select(t => t.Id).Intersect(candidates).Any()))
.Select(s => BuildCodeSnippet(s, SourcePosition.Create(cursorPosition - textToReplace.Length, cursorPosition))).ToArray());
}
public IEnumerable<ICodeSnippet> GetSnippets(SqlDocumentRepository sqlDocumentRepository, string statementText, int cursorPosition)
{
if (sqlDocumentRepository?.Statements == null)
{
return EmptyCollection;
}
var statement = sqlDocumentRepository.Statements.TakeWhile(s => s.SourcePosition.IndexStart <= cursorPosition - 1).LastOrDefault();
StatementGrammarNode currentNode = null;
if (statement != null)
{
currentNode =
statement.GetTerminalAtPosition(cursorPosition)
?? statement.GetNearestTerminalToPosition(cursorPosition);
}
if (currentNode != null &&
String.Equals(currentNode.Id, OracleGrammarDescription.Terminals.RightParenthesis) &&
!String.Equals(currentNode.ParentNode.Id, OracleGrammarDescription.NonTerminals.CommonTableExpression) &&
currentNode.PrecedingTerminal?.PrecedingTerminal != null)
{
currentNode = currentNode.PrecedingTerminal.PrecedingTerminal;
}
var textToReplace = new String(statementText.Substring(0, cursorPosition).Reverse().TakeWhile(c => !c.In(' ', '\n', '\t', '(', '\r', ';')).Reverse().ToArray());
if (String.IsNullOrWhiteSpace(textToReplace))
{
return EmptyCollection;
}
var candidates = OracleSqlParser.Instance.GetTerminalCandidates(currentNode).Select(c => c.Id);
return Snippets.SnippetCollection.Where(s => s.Name.ToUpperInvariant().Contains(textToReplace.ToUpperInvariant()) &&
(s.AllowedTerminals == null || s.AllowedTerminals.Length == 0 || s.AllowedTerminals.Select(t => t.Id).Intersect(candidates).Any()))
.Select(s => BuildCodeSnippet(s, SourcePosition.Create(cursorPosition - textToReplace.Length, cursorPosition))).ToArray();
}
public ICollection<ProgramOverloadDescription> ResolveProgramOverloads(SqlDocumentRepository documentRepository, int cursorPosition)
{
var emptyCollection = new ProgramOverloadDescription[0];
var node = documentRepository.Statements.GetNodeAtPosition(cursorPosition);
if (node == null)
{
return emptyCollection;
}
var semanticModel = (OracleStatementSemanticModel)documentRepository.ValidationModels[node.Statement].SemanticModel;
var referenceContainers = semanticModel.AllReferenceContainers;
var programOverloadSource = ResolveProgramOverloads(referenceContainers, node, cursorPosition);
var programOverloads = programOverloadSource
.Select(
o =>
{
var metadata = o.ProgramMetadata;
var returnParameter = metadata.ReturnParameter;
var parameters = metadata.Parameters
.Where(p => p.Direction != ParameterDirection.ReturnValue && p.DataLevel == 0)
.Select(BuildParameterLabel)
.ToArray();
return
new ProgramOverloadDescription
{
Name = metadata.Identifier.FullyQualifiedIdentifier,
Parameters = parameters,
CurrentParameterIndex = o.CurrentParameterIndex,
ReturnedDatatype = returnParameter?.FullDataTypeName
};
});
return programOverloads.ToArray();
}
public ICollection<ICodeCompletionItem> ResolveItems(SqlDocumentRepository sqlDocumentRepository, IDatabaseModel databaseModel, int cursorPosition, bool forcedInvokation)
{
if (sqlDocumentRepository?.Statements == null)
{
return EmptyCollection;
}
var completionType = new OracleCodeCompletionType(sqlDocumentRepository, sqlDocumentRepository.StatementText, cursorPosition);
//completionType.PrintResults();
if (completionType.InComment)
{
return EmptyCollection;
}
if (!forcedInvokation && !completionType.JoinCondition && String.IsNullOrEmpty(completionType.TerminalValuePartUntilCaret) && !completionType.IsCursorTouchingIdentifier)
{
return EmptyCollection;
}
StatementGrammarNode currentTerminal;
var completionItems = Enumerable.Empty<ICodeCompletionItem>();
var statement = (OracleStatement)sqlDocumentRepository.Statements.LastOrDefault(s => s.GetNodeAtPosition(cursorPosition) != null);
if (statement == null)
{
statement = completionType.Statement;
if (statement == null)
{
return EmptyCollection;
}
currentTerminal = statement.GetNearestTerminalToPosition(cursorPosition);
if (completionType.InUnparsedData || currentTerminal == null)
{
return EmptyCollection;
}
}
else
{
currentTerminal = statement.GetNodeAtPosition(cursorPosition);
if (currentTerminal.Type == NodeType.NonTerminal)
{
currentTerminal = statement.GetNearestTerminalToPosition(cursorPosition);
}
else if (currentTerminal.Id.In(Terminals.RightParenthesis, Terminals.Comma, Terminals.Semicolon))
{
var precedingNode = statement.GetNearestTerminalToPosition(cursorPosition - 1);
if (precedingNode != null)
{
currentTerminal = precedingNode;
}
}
}
var oracleDatabaseModel = (OracleDatabaseModelBase)databaseModel;
var semanticModel = (OracleStatementSemanticModel)sqlDocumentRepository.ValidationModels[statement].SemanticModel;
var cursorAtLastTerminal = cursorPosition <= currentTerminal.SourcePosition.IndexEnd + 1;
var terminalToReplace = completionType.ReferenceIdentifier.IdentifierUnderCursor;
var referenceContainers = GetReferenceContainers(semanticModel.MainObjectReferenceContainer, completionType.CurrentQueryBlock);
var extraOffset = currentTerminal.SourcePosition.ContainsIndex(cursorPosition) && !currentTerminal.Id.In(Terminals.LeftParenthesis, Terminals.Dot) ? 1 : 0;
if (completionType.SchemaDataObject)
{
var schemaName = completionType.ReferenceIdentifier.HasSchemaIdentifier
? currentTerminal.ParentNode.FirstTerminalNode.Token.Value
: databaseModel.CurrentSchema.ToQuotedIdentifier();
completionItems = completionItems.Concat(GenerateSchemaDataObjectItems(oracleDatabaseModel, schemaName, completionType.TerminalValuePartUntilCaret, terminalToReplace, insertOffset: extraOffset));
if (!completionType.ReferenceIdentifier.HasSchemaIdentifier)
{
completionItems = completionItems.Concat(GenerateSchemaDataObjectItems(oracleDatabaseModel, OracleObjectIdentifier.SchemaPublic, completionType.TerminalValuePartUntilCaret, terminalToReplace, insertOffset: extraOffset));
}
completionItems = completionItems.Concat(GenerateCommonTableExpressionReferenceItems(semanticModel, completionType.TerminalValuePartUntilCaret, terminalToReplace, extraOffset));
}
var joinClauseNode = currentTerminal.GetPathFilterAncestor(n => !String.Equals(n.Id, NonTerminals.FromClause), NonTerminals.JoinClause);
if (joinClauseNode != null && !cursorAtLastTerminal && currentTerminal.Id.In(Terminals.ObjectIdentifier, Terminals.ObjectAlias, Terminals.On))
{
var isNotInnerJoin = joinClauseNode.ChildNodes.SingleOrDefault(n => String.Equals(n.Id, NonTerminals.InnerJoinClause)) == null;
if (isNotInnerJoin || (!joinClauseNode.FirstTerminalNode.Id.In(Terminals.Cross, Terminals.Natural)))
{
var joinedTableReferenceNodes = joinClauseNode.GetPathFilterDescendants(n => !n.Id.In(NonTerminals.JoinClause, NonTerminals.NestedQuery), NonTerminals.TableReference).ToArray();
if (joinedTableReferenceNodes.Length == 1)
{
var joinedTableReference = completionType.CurrentQueryBlock.ObjectReferences.SingleOrDefault(t => t.RootNode == joinedTableReferenceNodes[0]);
if (joinedTableReference != null && (joinedTableReference.Type != ReferenceType.InlineView || joinedTableReference.AliasNode != null))
{
foreach (var parentTableReference in completionType.CurrentQueryBlock.ObjectReferences
.Where(t => t.RootNode.SourcePosition.IndexStart < joinedTableReference.RootNode.SourcePosition.IndexStart &&
(t.Type != ReferenceType.InlineView || t.AliasNode != null)))
{
var joinSuggestions = GenerateJoinConditionSuggestionItems(parentTableReference, joinedTableReference, completionType, extraOffset);
completionItems = completionItems.Concat(joinSuggestions);
}
}
}
}
}
if (completionType.JoinType)
{
completionItems = completionItems.Concat(CreateJoinTypeCompletionItems(completionType));
}
if (String.Equals(currentTerminal.Id, Terminals.Join) ||
(String.Equals(currentTerminal.Id, Terminals.ObjectAlias) && String.Equals(((OracleToken)currentTerminal.Token).UpperInvariantValue, TerminalValues.Join)))
{
completionItems = completionItems.Concat(GenerateSchemaDataObjectItems(oracleDatabaseModel, databaseModel.CurrentSchema.ToQuotedIdentifier(), null, null, insertOffset: extraOffset));
completionItems = completionItems.Concat(GenerateSchemaDataObjectItems(oracleDatabaseModel, OracleObjectIdentifier.SchemaPublic, null, null, insertOffset: extraOffset));
completionItems = completionItems.Concat(GenerateCommonTableExpressionReferenceItems(semanticModel, null, null, extraOffset));
}
if (completionType.Column || completionType.PlSqlCompletion != PlSqlCompletion.None)
{
completionItems = completionItems.Concat(GenerateSelectListItems(referenceContainers, cursorPosition, oracleDatabaseModel, completionType, forcedInvokation));
}
if (completionType.Column || completionType.SpecialFunctionParameter)
{
var programOverloads = ResolveProgramOverloads(referenceContainers, currentTerminal, cursorPosition);
var specificFunctionParameterCodeCompletionItems = CodeCompletionSearchHelper.ResolveSpecificFunctionParameterCodeCompletionItems(currentTerminal, programOverloads, oracleDatabaseModel);
completionItems = completionItems.Concat(specificFunctionParameterCodeCompletionItems);
}
if (completionType.ColumnAlias)
{
completionItems = completionItems.Concat(GenerateColumnAliases(terminalToReplace, completionType));
}
if (completionType.UpdateSetColumn && semanticModel.MainObjectReferenceContainer.MainObjectReference != null)
{
completionItems = completionItems.Concat(GenerateSimpleColumnItems(semanticModel.MainObjectReferenceContainer.MainObjectReference, completionType));
}
if (completionType.InsertIntoColumn)
{
var columnList = currentTerminal.GetAncestor(NonTerminals.ParenthesisEnclosedPrefixedIdentifierList);
var insertTarget = semanticModel.InsertTargets.SingleOrDefault(t => t.ColumnListNode == columnList && t.DataObjectReference != null);
if (insertTarget != null)
{
completionItems = completionItems.Concat(GenerateSimpleColumnItems(insertTarget.DataObjectReference, completionType));
}
}
if (completionType.DatabaseLink)
{
var databaseLinkItems = oracleDatabaseModel.DatabaseLinks.Values
.Where(
l =>
l.FullyQualifiedName.NormalizedOwner.In(OracleObjectIdentifier.SchemaPublic, oracleDatabaseModel.CurrentSchema.ToQuotedIdentifier()) &&
(String.IsNullOrEmpty(completionType.TerminalValueUnderCursor) || !String.Equals(completionType.TerminalValueUnderCursor.ToQuotedIdentifier(), l.FullyQualifiedName.NormalizedName)) &&
CodeCompletionSearchHelper.IsMatch(l.FullyQualifiedName.Name, completionType.TerminalValuePartUntilCaret))
.Select(
l =>
new OracleCodeCompletionItem
{
Name = l.FullyQualifiedName.Name.ToSimpleIdentifier(),
Text = l.FullyQualifiedName.Name.ToSimpleIdentifier(),
Category = OracleCodeCompletionCategory.DatabaseLink,
StatementNode = completionType.CurrentTerminal
});
completionItems = completionItems.Concat(databaseLinkItems);
}
if (completionType.ExplicitPartition || completionType.ExplicitSubPartition)
{
var tableReferenceNode = completionType.EffectiveTerminal.GetAncestor(NonTerminals.TableReference);
var tableReference = referenceContainers.SelectMany(c => c.ObjectReferences).SingleOrDefault(o => o.RootNode == tableReferenceNode && o.SchemaObject != null);
if (tableReference != null)
{
completionItems = completionItems.Concat(GenerateTablePartitionItems(tableReference, completionType, completionType.ExplicitSubPartition));
}
}
if (completionType.DataType)
{
completionItems = completionItems.Concat(GenerateDataTypeItems(completionType, oracleDatabaseModel));
}
if (completionType.Schema && !completionType.UpdateSetColumn &&
(!completionType.ReferenceIdentifier.HasSchemaIdentifier || String.Equals(completionType.EffectiveTerminal.Id, Terminals.SchemaIdentifier)))
{
completionItems = completionItems.Concat(GenerateSchemaItems(completionType, terminalToReplace, extraOffset, oracleDatabaseModel, 2));
}
if (completionType.BindVariable)
{
var providerConfiguration = WorkDocumentCollection.GetProviderConfiguration(oracleDatabaseModel.ConnectionString.ProviderName);
var currentNormalizedValue = completionType.TerminalValuePartUntilCaret.ToQuotedIdentifier();
var bindVariables =
providerConfiguration.BindVariables.Where(bv => bv.Value != null && !Equals(bv.Value, String.Empty) && !Equals(bv.Value, DateTime.MinValue) && !String.Equals(bv.Name.ToQuotedIdentifier(), currentNormalizedValue) && CodeCompletionSearchHelper.IsMatch(bv.Name.ToQuotedIdentifier(), completionType.TerminalValuePartUntilCaret))
.Select(
bv =>
new OracleCodeCompletionItem
{
Name = bv.Name,
Text = bv.Name,
Category = OracleCodeCompletionCategory.BindVariable,
StatementNode = completionType.ReferenceIdentifier.IdentifierUnderCursor
});
completionItems = completionItems.Concat(bindVariables);
}
completionItems = completionItems.Concat(GenerateKeywordItems(completionType));
return completionItems.OrderItems().ToArray();
// TODO: Add option to search all/current/public schemas
}
internal ICollection<ICodeCompletionItem> ResolveItems(IDatabaseModel databaseModel, string statementText, int cursorPosition, bool forcedInvokation = true, params string[] categories)
{
var documentStore = new SqlDocumentRepository(OracleSqlParser.Instance, new OracleStatementValidator(), databaseModel, statementText);
var sourceItems = ResolveItems(documentStore, databaseModel, cursorPosition, forcedInvokation);
return sourceItems.Where(i => categories.Length == 0 || categories.Contains(i.Category)).ToArray();
}
public ICollection <ContextAction> GetAvailableRefactorings(SqlDocumentRepository sqlDocumentRepository, ActionExecutionContext executionContext)
{
throw new NotImplementedException();
}
public ICollection <ContextAction> GetContextActions(SqlDocumentRepository sqlDocumentRepository, ActionExecutionContext executionContext)
{
if (sqlDocumentRepository?.Statements == null || executionContext.StatementText != sqlDocumentRepository.StatementText)
{
return(EmptyCollection);
}
var currentTerminal = sqlDocumentRepository.Statements.GetTerminalAtPosition(executionContext.CaretOffset);
if (currentTerminal == null)
{
return(EmptyCollection);
}
var precedingTerminal = currentTerminal.PrecedingTerminal;
if (currentTerminal.SourcePosition.IndexStart == executionContext.CaretOffset && precedingTerminal != null && precedingTerminal.SourcePosition.IndexEnd + 1 == executionContext.CaretOffset &&
currentTerminal.Id.In(Terminals.Comma, Terminals.LeftParenthesis, Terminals.RightParenthesis))
{
currentTerminal = precedingTerminal;
}
var semanticModel = (OracleStatementSemanticModel)sqlDocumentRepository.ValidationModels[currentTerminal.Statement].SemanticModel;
var settings = new CommandSettingsModel {
Value = "Enter value"
};
executionContext.SettingsProvider = _commandSettingsProviderFactory.CreateCommandSettingsProvider(settings);
var actionList = new List <ContextAction>();
if (OracleCommands.AddAlias.CanExecuteHandler(executionContext))
{
actionList.Add(new ContextAction(AddAliasCommand.Title, OracleCommands.AddAlias, executionContext));
}
if (OracleCommands.WrapAsInlineView.CanExecuteHandler(executionContext))
{
actionList.Add(new ContextAction(WrapAsInlineViewCommand.Title, OracleCommands.WrapAsInlineView, executionContext));
}
if (OracleCommands.WrapAsCommonTableExpression.CanExecuteHandler(executionContext))
{
actionList.Add(new ContextAction(WrapAsCommonTableExpressionCommand.Title, OracleCommands.WrapAsCommonTableExpression, executionContext));
}
if (OracleCommands.ToggleQuotedNotation.CanExecuteHandler(executionContext))
{
actionList.Add(new ContextAction(ToggleQuotedNotationCommand.Title, OracleCommands.ToggleQuotedNotation, executionContext));
}
if (OracleCommands.AddToGroupByClause.CanExecuteHandler(executionContext))
{
actionList.Add(new ContextAction(AddToGroupByCommand.Title, OracleCommands.AddToGroupByClause, executionContext));
}
if (OracleCommands.AddToOrderByClause.CanExecuteHandler(executionContext))
{
actionList.Add(new ContextAction(AddToOrderByCommand.Title, OracleCommands.AddToOrderByClause, executionContext));
}
var canExecuteResult = OracleCommands.ExpandAsterisk.CanExecuteHandler(executionContext);
if (canExecuteResult)
{
actionList.Add(new ContextAction(ExpandAsteriskCommand.Title, OracleCommands.ExpandAsterisk, CloneContextWithUseDefaultSettingsOption(executionContext), canExecuteResult.IsLongOperation));
}
if (OracleCommands.UnnestInlineView.CanExecuteHandler(executionContext))
{
actionList.Add(new ContextAction(UnnestInlineViewCommand.Title, OracleCommands.UnnestInlineView, executionContext));
}
if (OracleCommands.ToggleFullyQualifiedReferences.CanExecuteHandler(executionContext))
{
actionList.Add(new ContextAction(ToggleFullyQualifiedReferencesCommand.Title, OracleCommands.ToggleFullyQualifiedReferences, executionContext));
}
if (OracleCommands.AddMissingColumn.CanExecuteHandler(executionContext))
{
actionList.Add(new ContextAction(AddMissingColumnCommand.Title, OracleCommands.AddMissingColumn, executionContext));
}
canExecuteResult = OracleCommands.CreateScript.CanExecuteHandler(executionContext);
if (canExecuteResult)
{
actionList.Add(new ContextAction(CreateScriptCommand.Title, OracleCommands.CreateScript, CloneContextWithUseDefaultSettingsOption(executionContext), canExecuteResult.IsLongOperation));
}
if (OracleCommands.AddInsertIntoColumnList.CanExecuteHandler(executionContext))
{
actionList.Add(new ContextAction(AddInsertIntoColumnListCommand.Title, OracleCommands.AddInsertIntoColumnList, CloneContextWithUseDefaultSettingsOption(executionContext)));
}
if (OracleCommands.CleanRedundantSymbol.CanExecuteHandler(executionContext))
{
actionList.Add(new ContextAction(CleanRedundantSymbolCommand.Title, OracleCommands.CleanRedundantSymbol, executionContext));
}
if (OracleCommands.AddCreateTableAs.CanExecuteHandler(executionContext))
{
actionList.Add(new ContextAction(AddCreateTableAsCommand.Title, OracleCommands.AddCreateTableAs, executionContext));
}
if (OracleCommands.Unquote.CanExecuteHandler(executionContext))
{
actionList.Add(new ContextAction(UnquoteCommand.Title, OracleCommands.Unquote, executionContext));
}
if (OracleCommands.PropagateColumn.CanExecuteHandler(executionContext))
{
actionList.Add(new ContextAction(PropagateColumnCommand.Title, OracleCommands.PropagateColumn, executionContext));
}
if (OracleCommands.ConvertOrderByNumberColumnReferences.CanExecuteHandler(executionContext))
{
actionList.Add(new ContextAction(ConvertOrderByNumberColumnReferencesCommand.Title, OracleCommands.ConvertOrderByNumberColumnReferences, executionContext));
}
if (OracleCommands.GenerateCustomTypeCSharpWrapperClass.CanExecuteHandler(executionContext))
{
actionList.Add(new ContextAction(GenerateCustomTypeCSharpWrapperClassCommand.Title, OracleCommands.GenerateCustomTypeCSharpWrapperClass, executionContext));
}
if (OracleCommands.SplitString.CanExecuteHandler(executionContext))
{
actionList.Add(new ContextAction(SplitStringCommand.Title, OracleCommands.SplitString, executionContext));
}
if (OracleCommands.ExtractPackageInterface.CanExecuteHandler(executionContext))
{
actionList.Add(new ContextAction(ExtractPackageInterfaceCommand.Title, OracleCommands.ExtractPackageInterface, executionContext));
}
if (OracleCommands.ExpandView.CanExecuteHandler(executionContext))
{
actionList.Add(new ContextAction(ExpandViewCommand.Title, OracleCommands.ExpandView, executionContext, true));
}
if (OracleCommands.ConfigureNamedParameters.CanExecuteHandler(executionContext))
{
actionList.Add(new ContextAction(ConfigureNamedParameterCommand.Title, OracleCommands.ConfigureNamedParameters, CloneContextWithUseDefaultSettingsOption(executionContext)));
}
var actions =
ResolveAmbiguousColumnCommand.ResolveCommandHandlers(semanticModel, currentTerminal)
.Select(c => new ContextAction("Resolve as " + c.Name, c, executionContext));
actionList.AddRange(actions);
actions =
BindVariableLiteralConversionCommand.ResolveCommandHandlers(semanticModel, currentTerminal)
.Select(c => new ContextAction(c.Name, c, executionContext));
actionList.AddRange(actions);
actions =
LiteralBindVariableConversionCommand.ResolveCommandHandlers(semanticModel, currentTerminal)
.Select(c => new ContextAction(c.Name, c, executionContext));
actionList.AddRange(actions);
// TODO: Resolve command order
return(actionList.AsReadOnly());
}
public void TestToolTipBeforeDatabaseModelLoaded()
{
const string query = "SELECT S.* FROM SELECTION S";
_documentRepository.UpdateStatements(query);
var databaseModel = new OracleTestDatabaseModel();
databaseModel.AllObjects.Clear();
var documentStore = new SqlDocumentRepository(OracleSqlParser.Instance, new OracleStatementValidator(), databaseModel, query);
var toolTip = _toolTipProvider.GetToolTip(documentStore, 7);
toolTip.ShouldBe(null);
}
internal IEnumerable<ICodeSnippet> GetSnippets(string statementText, int cursorPosition, IDatabaseModel databaseModel)
{
var documentStore = new SqlDocumentRepository(OracleSqlParser.Instance, new OracleStatementValidator(), databaseModel, statementText);
return GetSnippets(documentStore, statementText, cursorPosition);
}
public void SetUp()
{
_documentRepository = TestFixture.CreateDocumentRepository();
}
internal IEnumerable <ICodeSnippet> GetSnippets(string statementText, int cursorPosition, IDatabaseModel databaseModel)
{
var documentStore = new SqlDocumentRepository(OracleSqlParser.Instance, new OracleStatementValidator(), databaseModel, statementText);
return(GetSnippets(documentStore, statementText, cursorPosition));
}
public IEnumerable <ICodeSnippet> GetCodeGenerationItems(SqlDocumentRepository sqlDocumentRepository)
{
return(Snippets.CodeGenerationItemCollection.Select(s => BuildCodeSnippet(s, SourcePosition.Empty))
.OrderBy(s => s.Name));
}
public OracleCodeCompletionType(SqlDocumentRepository documentRepository, string statementText, int cursorPosition)
{
CursorPosition = cursorPosition;
Statement = (OracleStatement)(documentRepository.Statements.GetStatementAtPosition(cursorPosition) ?? documentRepository.Statements.LastOrDefault());
if (Statement == null)
{
return;
}
if (Statement.TerminatorNode != null && Statement.TerminatorNode.SourcePosition.IndexStart < cursorPosition)
{
return;
}
var nearestTerminal = Statement.GetNearestTerminalToPosition(cursorPosition);
if (nearestTerminal == null)
{
return;
}
var precedingTerminal = nearestTerminal.PrecedingTerminal;
InComment = Statement.Comments.Any(c => c.SourcePosition.ContainsIndex(cursorPosition));
if (!documentRepository.ValidationModels.TryGetValue(Statement, out IValidationModel validationModel))
{
return;
}
SemanticModel = (OracleStatementSemanticModel)validationModel.SemanticModel;
var requiredOffsetAfterToken = nearestTerminal.Id.IsZeroOffsetTerminalId() ? 0 : 1;
var isCursorAfterToken = nearestTerminal.SourcePosition.IndexEnd + requiredOffsetAfterToken < cursorPosition;
var atAdHocTemporaryTerminal = false;
if (isCursorAfterToken)
{
var unparsedTextBetweenTokenAndCursor = statementText.Substring(nearestTerminal.SourcePosition.IndexEnd + 1, cursorPosition - nearestTerminal.SourcePosition.IndexEnd - 1);
var unparsedEndTrimmedTextBetweenTokenAndCursor = unparsedTextBetweenTokenAndCursor.TrimEnd();
OracleToken[] extraUnparsedTokens;
using (var tokenReader = OracleTokenReader.Create(unparsedEndTrimmedTextBetweenTokenAndCursor))
{
extraUnparsedTokens = tokenReader.GetTokens(true).ToArray();
}
if (extraUnparsedTokens.Length > 0)
{
TerminalCandidates = OracleSqlParser.Instance.GetTerminalCandidates(nearestTerminal);
if (TerminalCandidates.Count == 0 || extraUnparsedTokens.Length > 1 || unparsedEndTrimmedTextBetweenTokenAndCursor.Length < unparsedTextBetweenTokenAndCursor.Length)
{
InUnparsedData = true;
return;
}
}
TerminalValueUnderCursor = extraUnparsedTokens.FirstOrDefault().Value;
if (TerminalValueUnderCursor != null)
{
TerminalValuePartUntilCaret = TerminalValueUnderCursor;
precedingTerminal = nearestTerminal;
nearestTerminal = CurrentTerminal = new StatementGrammarNode(NodeType.Terminal, Statement, new OracleToken(TerminalValueUnderCursor, cursorPosition - TerminalValuePartUntilCaret.Length));
precedingTerminal.ParentNode.Clone().AddChildNodes(nearestTerminal);
atAdHocTemporaryTerminal = true;
nearestTerminal.Id = nearestTerminal.Token.Value[0] == '"'
? Terminals.Identifier
: GetIdentifierCandidate();
if (nearestTerminal.Id != null)
{
ReferenceIdentifier = BuildReferenceIdentifier(nearestTerminal.ParentNode.GetDescendants(Terminals.SchemaIdentifier, Terminals.ObjectIdentifier, Terminals.Identifier).ToArray());
}
if (!String.IsNullOrEmpty(TerminalValueUnderCursor) && nearestTerminal.SourcePosition.ContainsIndex(cursorPosition))
{
isCursorAfterToken = false;
}
TerminalValueUnderCursor = TerminalValueUnderCursor.Trim('"');
}
}
else
{
CurrentTerminal = nearestTerminal;
ResolveCurrentTerminalValue(nearestTerminal);
}
var effectiveTerminal = Statement.GetNearestTerminalToPosition(cursorPosition, n => !n.Id.In(Terminals.LeftParenthesis, Terminals.RightParenthesis, Terminals.Comma, Terminals.Semicolon)) ?? nearestTerminal;
CurrentQueryBlock = SemanticModel.GetQueryBlock(effectiveTerminal);
AnalyzeObjectReferencePrefixes(effectiveTerminal);
var isCursorAfterEffectiveTerminal = cursorPosition > effectiveTerminal.SourcePosition.IndexEnd + 1;
if (precedingTerminal == null && nearestTerminal != Statement.RootNode.FirstTerminalNode)
{
precedingTerminal = nearestTerminal;
}
var isCursorTouchingTwoTerminals = nearestTerminal.SourcePosition.IndexStart == cursorPosition && precedingTerminal != null && precedingTerminal.SourcePosition.IndexEnd + 1 == cursorPosition;
if (isCursorTouchingTwoTerminals && !String.Equals(nearestTerminal.Id, Terminals.Identifier))
{
IsCursorTouchingIdentifier = String.Equals(precedingTerminal.Id, Terminals.Identifier);
EffectiveTerminal = precedingTerminal;
}
else
{
EffectiveTerminal = nearestTerminal;
}
var isColon = String.Equals(EffectiveTerminal.Id, Terminals.Colon);
if (!String.Equals(Statement.RootNode.Id, NonTerminals.CreatePlSqlStatement))
{
BindVariable = isColon && (String.Equals(EffectiveTerminal.ParentNode.Id, NonTerminals.AssignmentTriggerReferenceTarget) || String.Equals(EffectiveTerminal.ParentNode.Id, NonTerminals.BindVariableExpression));
BindVariable |= String.Equals(EffectiveTerminal.Id, Terminals.BindVariableIdentifier);
}
var terminalCandidateSourceToken = isCursorAfterToken || isColon ? nearestTerminal : precedingTerminal;
if (nearestTerminal.Id.In(Terminals.RightParenthesis, Terminals.Comma, Terminals.Dot, Terminals.Semicolon) && isCursorTouchingTwoTerminals && precedingTerminal.Id.IsIdentifier())
{
terminalCandidateSourceToken = precedingTerminal.PrecedingTerminal;
ResolveCurrentTerminalValue(precedingTerminal);
}
if (TerminalCandidates == null)
{
TerminalCandidates = OracleSqlParser.Instance.GetTerminalCandidates(terminalCandidateSourceToken);
}
InSelectList = (atAdHocTemporaryTerminal ? precedingTerminal : EffectiveTerminal).GetPathFilterAncestor(n => !String.Equals(n.Id, NonTerminals.QueryBlock), NonTerminals.SelectList) != null;
var invalidGrammarFilteredNearestTerminal = Statement.GetNearestTerminalToPosition(cursorPosition, n => !String.Equals(n.Id, Terminals.ObjectAlias));
var isWithinExplicitPartitionClause = invalidGrammarFilteredNearestTerminal != null && String.Equals(invalidGrammarFilteredNearestTerminal.ParentNode.Id, NonTerminals.PartitionNameOrKeySet) && (invalidGrammarFilteredNearestTerminal != nearestTerminal || TerminalCandidates.Contains(Terminals.ObjectIdentifier));
ExplicitPartition = isWithinExplicitPartitionClause && String.Equals(invalidGrammarFilteredNearestTerminal.ParentNode.ParentNode.FirstTerminalNode.Id, Terminals.Partition);
ExplicitSubPartition = isWithinExplicitPartitionClause && String.Equals(invalidGrammarFilteredNearestTerminal.ParentNode.ParentNode.FirstTerminalNode.Id, Terminals.Subpartition);
if (isWithinExplicitPartitionClause)
{
if (String.Equals(EffectiveTerminal.Id, Terminals.ObjectIdentifier))
{
ReferenceIdentifier = BuildReferenceIdentifier(new[] { EffectiveTerminal });
}
if (invalidGrammarFilteredNearestTerminal != nearestTerminal)
{
EffectiveTerminal = invalidGrammarFilteredNearestTerminal;
TerminalValuePartUntilCaret = null;
}
}
if (!isWithinExplicitPartitionClause)
{
ResolveSuggestedKeywords();
}
var isCursorBetweenTwoTerminalsWithPrecedingIdentifierWithoutPrefix = IsCursorTouchingIdentifier && !ReferenceIdentifier.HasObjectIdentifier;
Schema =
TerminalCandidates.Contains(Terminals.SchemaIdentifier) ||
(String.Equals(EffectiveTerminal.Id, Terminals.SchemaIdentifier) && String.Equals(nearestTerminal.Id, Terminals.Dot));
var isCurrentClauseSupported =
EffectiveTerminal.IsWithinSelectClauseOrExpression() ||
EffectiveTerminal.ParentNode.Id.In(NonTerminals.WhereClause, NonTerminals.GroupByClause, NonTerminals.HavingClause, NonTerminals.OrderByClause) ||
EffectiveTerminal.GetPathFilterAncestor(n => !String.Equals(n.Id, NonTerminals.NestedQuery), NonTerminals.WhereClause) != null;
var isCandidateIdentifier = TerminalCandidates.Contains(Terminals.Identifier);
if (isCurrentClauseSupported)
{
SchemaProgram = Column = isCandidateIdentifier || isCursorBetweenTwoTerminalsWithPrecedingIdentifierWithoutPrefix;
var functionParameterOptionalExpression = EffectiveTerminal.GetPathFilterAncestor(n => !String.Equals(n.Id, NonTerminals.OptionalParameterExpressionList), NonTerminals.OptionalParameterExpression);
if (functionParameterOptionalExpression != null)
{
var functionParameterExpression = functionParameterOptionalExpression[NonTerminals.Expression];
SpecialFunctionParameter = functionParameterExpression != null && functionParameterExpression.TerminalCount == 1 && (functionParameterExpression.FirstTerminalNode.Id.IsLiteral() || String.Equals(functionParameterExpression.FirstTerminalNode.Id, Terminals.Identifier));
}
}
DatabaseLink = TerminalCandidates.Contains(Terminals.DatabaseLinkIdentifier);
JoinType = (!isCursorTouchingTwoTerminals || nearestTerminal.Id.In(Terminals.Comma, Terminals.RightParenthesis)) && !isWithinExplicitPartitionClause && TerminalCandidates.Contains(Terminals.Join);
DataType = TerminalCandidates.Contains(Terminals.DataTypeIdentifier);
InQueryBlockFromClause = effectiveTerminal.GetPathFilterAncestor(n => !String.Equals(n.Id, NonTerminals.QueryBlock), NonTerminals.FromClause) != null || (effectiveTerminal.Id == Terminals.From && effectiveTerminal.ParentNode.Id == NonTerminals.QueryBlock);
var isWithinJoinCondition = effectiveTerminal.GetPathFilterAncestor(n => !String.Equals(n.Id, NonTerminals.JoinClause) && !String.Equals(n.Id, NonTerminals.NestedQuery), NonTerminals.JoinColumnsOrCondition) != null;
var isAfterUpdateOrDeleteTerminal = (nearestTerminal.Id.In(Terminals.Update, Terminals.Delete) || (String.Equals(nearestTerminal.Id, Terminals.From) && nearestTerminal.PrecedingTerminal != null && String.Equals(nearestTerminal.PrecedingTerminal.Id, Terminals.Delete))) && isCursorAfterToken;
var isWithinQueryBlock = nearestTerminal.GetAncestor(NonTerminals.QueryBlock) != null;
var isWithinMainObjectReference = nearestTerminal.GetAncestor(NonTerminals.TableReference) != null && !isWithinQueryBlock;
var isInInsertIntoTableReference = nearestTerminal.GetPathFilterAncestor(NodeFilters.BreakAtNestedQueryBlock, NonTerminals.DmlTableExpressionClause) != null ||
(nearestTerminal.GetPathFilterAncestor(NodeFilters.BreakAtNestedQueryBlock, NonTerminals.InsertIntoClause) != null && nearestTerminal.Id == Terminals.Into && isCursorAfterToken);
SchemaDataObject = (InQueryBlockFromClause || isAfterUpdateOrDeleteTerminal || isWithinMainObjectReference || isInInsertIntoTableReference) && !isWithinJoinCondition && !isWithinExplicitPartitionClause && TerminalCandidates.Contains(Terminals.ObjectIdentifier);
var isWithinJoinClause = effectiveTerminal.GetPathFilterAncestor(n => !String.Equals(n.Id, NonTerminals.FromClause), NonTerminals.JoinClause) != null;
JoinCondition = isWithinJoinClause && isCursorAfterEffectiveTerminal && (TerminalCandidates.Contains(Terminals.On) || String.Equals(nearestTerminal.Id, Terminals.On));
var isWithinSelectList = (String.Equals(nearestTerminal.Id, Terminals.Select) && isCursorAfterToken) || nearestTerminal.GetPathFilterAncestor(n => !String.Equals(n.Id, NonTerminals.QueryBlock), NonTerminals.SelectList) != null;
AllColumns = isWithinSelectList && TerminalCandidates.Contains(Terminals.Asterisk);
SchemaDataObjectReference = !InQueryBlockFromClause && (TerminalCandidates.Contains(Terminals.ObjectIdentifier) || isCursorBetweenTwoTerminalsWithPrecedingIdentifierWithoutPrefix);
PackageFunction = !String.IsNullOrEmpty(ReferenceIdentifier.ObjectIdentifierOriginalValue) && (isCandidateIdentifier || isCursorTouchingTwoTerminals);
var inMainQueryBlockOrMainObjectReference = CurrentQueryBlock == SemanticModel.MainQueryBlock || (CurrentQueryBlock == null && SemanticModel.MainObjectReferenceContainer.MainObjectReference != null);
Sequence = inMainQueryBlockOrMainObjectReference && (nearestTerminal.IsWithinSelectClause() || !nearestTerminal.IsWithinExpression() || nearestTerminal.GetPathFilterAncestor(n => n.Id != NonTerminals.QueryBlock, NonTerminals.InsertValuesClause) != null);
var isWithinUpdateSetNonTerminal = String.Equals(nearestTerminal.ParentNode.Id, NonTerminals.PrefixedIdentifier) || nearestTerminal.GetPathFilterAncestor(NodeFilters.BreakAtNestedQueryBlock, NonTerminals.SetColumnListEqualsNestedQuery) != null;
var isAfterSetTerminal = isCursorAfterToken && String.Equals(nearestTerminal.Id, Terminals.Set);
var isAfterCommaInChainedUpdateSetClause = isCursorAfterToken && String.Equals(nearestTerminal.Id, Terminals.Comma) && String.Equals(nearestTerminal.ParentNode.Id, NonTerminals.UpdateSetColumnOrColumnListChainedList);
UpdateSetColumn = isCandidateIdentifier && (isWithinUpdateSetNonTerminal || isAfterSetTerminal || isAfterCommaInChainedUpdateSetClause);
var columnList = nearestTerminal.GetAncestor(NonTerminals.ParenthesisEnclosedPrefixedIdentifierList);
InsertIntoColumn = isCandidateIdentifier && String.Equals(columnList?.ParentNode?.Id, NonTerminals.InsertIntoClause);
ColumnAlias = Column && nearestTerminal.IsWithinOrderByClause();
}
public IEnumerable<ICodeSnippet> GetCodeGenerationItems(SqlDocumentRepository sqlDocumentRepository)
{
return Snippets.CodeGenerationItemCollection.Select(s => BuildCodeSnippet(s, SourcePosition.Empty))
.OrderBy(s => s.Name);
}
public void SetUp()
{
_documentRepository = TestFixture.CreateDocumentRepository();
}
public IToolTip GetToolTip(SqlDocumentRepository sqlDocumentRepository, int cursorPosition)
{
if (sqlDocumentRepository == null)
{
throw new ArgumentNullException(nameof(sqlDocumentRepository));
}
var node = sqlDocumentRepository.Statements.GetNodeAtPosition(cursorPosition);
if (node == null)
{
var statement = sqlDocumentRepository.Statements.GetStatementAtPosition(cursorPosition);
if (statement?.FirstUnparsedToken == null)
{
return(null);
}
if (cursorPosition < statement.FirstUnparsedToken.Index || cursorPosition > statement.FirstUnparsedToken.Index + statement.FirstUnparsedToken.Value.Length)
{
return(null);
}
return(BuildExpectedTokenListToolTip(statement.LastTerminalNode));
}
var tip = node.Type == NodeType.Terminal && !node.Id.IsIdentifier() ? node.Id : null;
var validationModel = (OracleValidationModel)sqlDocumentRepository.ValidationModels[node.Statement];
var nodeSemanticError = validationModel.SemanticErrors
.Concat(validationModel.Suggestions)
.FirstOrDefault(v => node.HasAncestor(v.Node, true));
if (nodeSemanticError != null)
{
tip = nodeSemanticError.ToolTipText;
}
else
{
var semanticModel = validationModel.SemanticModel;
var queryBlock = semanticModel.GetQueryBlock(node);
var toolTipBuilderVisitor = new OracleToolTipBuilderVisitor(node);
switch (node.Id)
{
case Terminals.Asterisk:
return(BuildAsteriskToolTip(queryBlock, node));
case Terminals.Min:
case Terminals.Max:
case Terminals.Sum:
case Terminals.Avg:
case Terminals.FirstValue:
case Terminals.Count:
case Terminals.Cast:
case Terminals.Trim:
case Terminals.CharacterCode:
case Terminals.Variance:
case Terminals.StandardDeviation:
case Terminals.LastValue:
case Terminals.Lead:
case Terminals.Lag:
case Terminals.ListAggregation:
case Terminals.CumulativeDistribution:
case Terminals.Rank:
case Terminals.DenseRank:
case Terminals.PercentileDiscreteDistribution:
case Terminals.PercentileContinuousDistribution:
case Terminals.NegationOrNull:
case Terminals.RowIdPseudocolumn:
case Terminals.RowNumberPseudocolumn:
case Terminals.User:
case Terminals.Level:
case Terminals.Extract:
case Terminals.JsonQuery:
case Terminals.JsonExists:
case Terminals.JsonValue:
case Terminals.XmlCast:
case Terminals.XmlElement:
case Terminals.XmlSerialize:
case Terminals.XmlParse:
case Terminals.XmlQuery:
case Terminals.XmlRoot:
case Terminals.XmlForest:
case Terminals.PlSqlIdentifier:
case Terminals.ExceptionIdentifier:
case Terminals.CursorIdentifier:
case Terminals.DataTypeIdentifier:
case Terminals.ObjectIdentifier:
case Terminals.SchemaIdentifier:
case Terminals.Identifier:
var reference = semanticModel.GetReference <OracleReference>(node);
reference?.Accept(toolTipBuilderVisitor);
if (toolTipBuilderVisitor.ToolTip != null)
{
return(toolTipBuilderVisitor.ToolTip);
}
goto default;
case Terminals.DatabaseLinkIdentifier:
case Terminals.Dot:
case Terminals.AtCharacter:
var databaseLink = semanticModel.GetReference <OracleReference>(node)?.DatabaseLink;
if (databaseLink == null)
{
return(null);
}
return
(new ToolTipDatabaseLink(databaseLink)
{
ScriptExtractor = semanticModel.DatabaseModel.ObjectScriptExtractor,
});
case Terminals.ParameterIdentifier:
return(BuildParameterToolTip(semanticModel, node));
default:
var missingTokenLookupTerminal = GetTerminalForCandidateLookup(node, node.LastTerminalNode);
if (missingTokenLookupTerminal != null)
{
return(BuildExpectedTokenListToolTip(node));
}
break;
}
}
return(String.IsNullOrEmpty(tip) ? null : new ToolTipObject {
DataContext = tip
});
}
public IToolTip GetToolTip(SqlDocumentRepository sqlDocumentRepository, int cursorPosition)
{
if (sqlDocumentRepository == null)
{
throw new ArgumentNullException(nameof(sqlDocumentRepository));
}
var node = sqlDocumentRepository.Statements.GetNodeAtPosition(cursorPosition);
if (node == null)
{
var statement = sqlDocumentRepository.Statements.GetStatementAtPosition(cursorPosition);
if (statement?.FirstUnparsedToken == null)
{
return null;
}
if (cursorPosition < statement.FirstUnparsedToken.Index || cursorPosition > statement.FirstUnparsedToken.Index + statement.FirstUnparsedToken.Value.Length)
{
return null;
}
return BuildExpectedTokenListToolTip(statement.LastTerminalNode);
}
var tip = node.Type == NodeType.Terminal && !node.Id.IsIdentifier() ? node.Id : null;
var validationModel = (OracleValidationModel)sqlDocumentRepository.ValidationModels[node.Statement];
var nodeSemanticError = validationModel.SemanticErrors
.Concat(validationModel.Suggestions)
.FirstOrDefault(v => node.HasAncestor(v.Node, true));
if (nodeSemanticError != null)
{
tip = nodeSemanticError.ToolTipText;
}
else
{
var semanticModel = validationModel.SemanticModel;
var queryBlock = semanticModel.GetQueryBlock(node);
var toolTipBuilderVisitor = new OracleToolTipBuilderVisitor(node);
switch (node.Id)
{
case Terminals.Asterisk:
return BuildAsteriskToolTip(queryBlock, node);
case Terminals.Min:
case Terminals.Max:
case Terminals.Sum:
case Terminals.Avg:
case Terminals.FirstValue:
case Terminals.Count:
case Terminals.Cast:
case Terminals.Trim:
case Terminals.CharacterCode:
case Terminals.Variance:
case Terminals.StandardDeviation:
case Terminals.LastValue:
case Terminals.Lead:
case Terminals.Lag:
case Terminals.ListAggregation:
case Terminals.CumulativeDistribution:
case Terminals.Rank:
case Terminals.DenseRank:
case Terminals.PercentileDiscreteDistribution:
case Terminals.PercentileContinuousDistribution:
case Terminals.NegationOrNull:
case Terminals.RowIdPseudocolumn:
case Terminals.RowNumberPseudocolumn:
case Terminals.User:
case Terminals.Level:
case Terminals.Extract:
case Terminals.JsonQuery:
case Terminals.JsonExists:
case Terminals.JsonValue:
case Terminals.XmlCast:
case Terminals.XmlElement:
case Terminals.XmlSerialize:
case Terminals.XmlParse:
case Terminals.XmlQuery:
case Terminals.XmlRoot:
case Terminals.XmlForest:
case Terminals.PlSqlIdentifier:
case Terminals.ExceptionIdentifier:
case Terminals.CursorIdentifier:
case Terminals.DataTypeIdentifier:
case Terminals.ObjectIdentifier:
case Terminals.SchemaIdentifier:
case Terminals.Identifier:
var reference = semanticModel.GetReference<OracleReference>(node);
reference?.Accept(toolTipBuilderVisitor);
if (toolTipBuilderVisitor.ToolTip != null)
{
return toolTipBuilderVisitor.ToolTip;
}
goto default;
case Terminals.DatabaseLinkIdentifier:
case Terminals.Dot:
case Terminals.AtCharacter:
var databaseLink = semanticModel.GetReference<OracleReference>(node)?.DatabaseLink;
if (databaseLink == null)
{
return null;
}
return
new ToolTipDatabaseLink(databaseLink)
{
ScriptExtractor = semanticModel.DatabaseModel.ObjectScriptExtractor,
};
case Terminals.ParameterIdentifier:
return BuildParameterToolTip(semanticModel, node);
default:
var missingTokenLookupTerminal = GetTerminalForCandidateLookup(node, node.LastTerminalNode);
if (missingTokenLookupTerminal != null)
{
return BuildExpectedTokenListToolTip(node);
}
break;
}
}
return String.IsNullOrEmpty(tip) ? null : new ToolTipObject { DataContext = tip };
}
