private static void ExecutionHandlerImplementation(ActionExecutionContext executionContext)
{
var commandInstance = new FindUsagesCommand(executionContext);
if (commandInstance.CanExecute())
{
commandInstance.ExecuteFindUsages();
}
}
private UnnestInlineViewCommand(ActionExecutionContext executionContext)
: base(executionContext)
{
_parentQueryBlock = SemanticModel?.QueryBlocks
.Select(qb => qb.ObjectReferences.FirstOrDefault(o => o.Type == ReferenceType.InlineView && o.QueryBlocks.Count == 1 && o.QueryBlocks.First() == CurrentQueryBlock))
.Where(o => o != null)
.Select(o => o.Owner)
.FirstOrDefault();
}
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;
}
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 static void UpdateDocument(SqlTextEditor editor, ActionExecutionContext executionContext)
{
var caretOffset = editor.CaretOffset;
var selectionLength = editor.SelectionLength;
editor.ReplaceTextSegments(executionContext.SegmentsToReplace);
var caretOffsetChanged = executionContext.CaretOffset != caretOffset;
if (executionContext.SelectionLength != selectionLength)
{
editor.SelectionStart = caretOffsetChanged ? executionContext.CaretOffset : editor.CaretOffset;
editor.SelectionLength = executionContext.SelectionLength;
}
if (caretOffsetChanged)
{
editor.CaretOffset = executionContext.CaretOffset;
editor.ScrollToCaret();
}
}
public void ShowHelp(ActionExecutionContext executionContext)
{
var statement = executionContext.DocumentRepository.Statements.GetStatementAtPosition(executionContext.CaretOffset);
if (statement == null)
{
return;
}
var semanticModel = (OracleStatementSemanticModel)executionContext.DocumentRepository.ValidationModels[statement].SemanticModel;
var terminal = statement.GetTerminalAtPosition(executionContext.CaretOffset, n => !String.Equals(n.Id, Terminals.Comma) && !String.Equals(n.Id, Terminals.Dot) && !String.Equals(n.Id, Terminals.RightParenthesis) && !String.Equals(n.Id, Terminals.LeftParenthesis));
if (terminal == null)
{
return;
}
EnsureDocumentationDictionaries();
var programReference = semanticModel.GetProgramReference(terminal);
if (programReference?.Metadata != null && programReference.Metadata.Type != ProgramType.StatementFunction)
{
ShowSqlFunctionDocumentation(programReference.Metadata.Identifier);
return;
}
var objectReference = semanticModel.GetReference<OracleReference>(terminal);
if (objectReference != null)
{
var targetObject = objectReference.SchemaObject.GetTargetSchemaObject();
DocumentationDataDictionaryObject dataDictionaryObject = null;
var dataDictionaryObjectDocumentationFound = targetObject != null && _dataDictionaryObjects.TryGetValue(targetObject.FullyQualifiedName, out dataDictionaryObject);
if (dataDictionaryObjectDocumentationFound)
{
Process.Start(dataDictionaryObject.Url);
}
}
var firstFourTerminals = terminal.RootNode.Terminals.Where(t => t.IsRequiredIncludingParent).Take(4).ToList();
if (!terminal.Id.IsIdentifierOrAlias() && firstFourTerminals.IndexOf(terminal) != -1)
{
for (var i = 4; i > 0; i--)
{
var statementDocumentationKey = String.Join(" ", firstFourTerminals.Take(i).Select(t => ((OracleToken)t.Token).UpperInvariantValue));
foreach (var documentation in _statementDocumentation[statementDocumentationKey])
{
Process.Start(documentation.Url);
return;
}
}
}
}
public StandardStatementFormatter(ActionExecutionContext executionContext) : base(executionContext)
{
_formatSelectionOnly = ExecutionContext.SelectionLength > 0;
}
private ToggleFullyQualifiedReferencesCommand(ActionExecutionContext executionContext)
: base(executionContext)
{
}
private static MultiNodeEditorData GetMultiNodeEditorData(string sqlText, int caretOffset)
{
DocumentRepository.UpdateStatements(sqlText);
var executionContext = new ActionExecutionContext(sqlText, caretOffset, caretOffset, 0, DocumentRepository);
return MultiNodeEditorDataProvider.GetMultiNodeEditorData(executionContext);
}
private AddMissingColumnCommand(ActionExecutionContext executionContext)
: base(executionContext)
{
}
private AddAliasCommand(ActionExecutionContext executionContext)
: base(executionContext)
{
}
public AliasCommandHelper(ActionExecutionContext executionContext)
{
_executionContext = executionContext;
}
private CreateScriptCommand(ActionExecutionContext executionContext)
: base(executionContext)
{
}
public MultiNodeEditorData GetMultiNodeEditorData(ActionExecutionContext executionContext)
{
var multiNodeData = new MultiNodeEditorData { SynchronizedSegments = new SourcePosition[0] };
var terminal = executionContext.DocumentRepository.Statements.GetTerminalAtPosition(executionContext.CaretOffset, n => !String.Equals(n.Id, Terminals.Comma) && !String.Equals(n.Id, Terminals.Dot) && !String.Equals(n.Id, Terminals.RightParenthesis));
if (executionContext.SelectionLength > 0 || terminal?.Id.IsIdentifierOrAlias() != true)
{
return multiNodeData;
}
multiNodeData.CurrentNode = terminal;
var semanticModel = (OracleStatementSemanticModel)executionContext.DocumentRepository.ValidationModels[terminal.Statement].SemanticModel;
OracleColumnReference columnReference;
OracleQueryBlock cteQueryBlock;
switch (terminal.Id)
{
case Terminals.ObjectAlias:
var objectReference = semanticModel.AllReferenceContainers
.SelectMany(c => c.ObjectReferences)
.SingleOrDefault(o => o.AliasNode == terminal);
var synchronizedSegments = new List<SourcePosition>();
cteQueryBlock = semanticModel.QueryBlocks.SingleOrDefault(qb => qb.AliasNode == terminal);
if (objectReference == null && cteQueryBlock != null)
{
synchronizedSegments.AddRange(GetDataObjectReferences(cteQueryBlock).Select(o => o.ObjectNode.SourcePosition));
}
var objectQualifiedColumnSynchronizedSegments = semanticModel.AllReferenceContainers
.SelectMany(c => c.ColumnReferences)
.Where(c => c.ObjectNode != null && c.ValidObjectReference != null && (c.ValidObjectReference == objectReference || IsCommonTableExpressionColumnReference(cteQueryBlock, c)))
.Concat(GetCommonTableExpressionObjectPrefixedColumnReferences(cteQueryBlock))
.Select(c => c.ObjectNode.SourcePosition);
synchronizedSegments.AddRange(objectQualifiedColumnSynchronizedSegments);
multiNodeData.SynchronizedSegments = synchronizedSegments.AsReadOnly();
break;
case Terminals.ObjectIdentifier:
var editNodes = new List<SourcePosition>();
columnReference = semanticModel.GetReference<OracleColumnReference>(terminal);
var objectReferences = new HashSet<OracleDataObjectReference>();
var dataObjectReferenceCandidate = columnReference?.ValidObjectReference as OracleDataObjectReference;
if (dataObjectReferenceCandidate != null)
{
objectReferences.Add(dataObjectReferenceCandidate);
}
else
{
dataObjectReferenceCandidate = semanticModel.GetReference<OracleDataObjectReference>(terminal);
}
if (dataObjectReferenceCandidate?.Type == ReferenceType.CommonTableExpression)
{
objectReferences.Add(dataObjectReferenceCandidate);
if (dataObjectReferenceCandidate.QueryBlocks.Count == 1)
{
cteQueryBlock = dataObjectReferenceCandidate.QueryBlocks.First();
var cteColumnReferences = GetCommonTableExpressionObjectPrefixedColumnReferences(cteQueryBlock);
editNodes.AddRange(cteColumnReferences.Select(c => c.ObjectNode.SourcePosition));
editNodes.AddRange(GetDataObjectReferences(cteQueryBlock).Where(o => o != dataObjectReferenceCandidate).Select(o => o.ObjectNode.SourcePosition));
StatementGrammarNode cteAliasNode;
if (cteQueryBlock.AliasNode == null)
{
cteQueryBlock = cteQueryBlock.AllPrecedingConcatenatedQueryBlocks.Last();
cteAliasNode = cteQueryBlock.AliasNode;
var referencesToCte = semanticModel.AllReferenceContainers.SelectMany(c => c.ObjectReferences).Where(o => o.QueryBlocks.Count == 1 && o.QueryBlocks.First() == cteQueryBlock);
objectReferences.UnionWith(referencesToCte);
}
else
{
cteAliasNode = cteQueryBlock.AliasNode;
}
editNodes.Add(cteAliasNode.SourcePosition);
}
}
foreach (var dataObjectReference in objectReferences)
{
if (dataObjectReference.AliasNode != null && columnReference != null)
{
editNodes.Add(dataObjectReference.AliasNode.SourcePosition);
}
else if (dataObjectReference.Type == ReferenceType.CommonTableExpression && dataObjectReference.ObjectNode != terminal)
{
editNodes.Add(dataObjectReference.ObjectNode.SourcePosition);
}
if (dataObjectReference.AliasNode == null || columnReference != null)
{
var editNodesSource = semanticModel.AllReferenceContainers
.SelectMany(c => c.ColumnReferences)
.Where(r => r.ObjectNode != null && r != columnReference && r.ValidObjectReference == dataObjectReference)
.Select(r => r.ObjectNode.SourcePosition);
editNodes.AddRange(editNodesSource);
}
}
multiNodeData.SynchronizedSegments = editNodes.AsReadOnly();
break;
case Terminals.BindVariableIdentifier:
var bindVariable = FindUsagesCommand.GetBindVariable(semanticModel, terminal.Token.Value);
multiNodeData.SynchronizedSegments = bindVariable.Nodes.Where(n => n != terminal).Select(t => t.SourcePosition).ToArray();
break;
case Terminals.ColumnAlias:
var selectListColumn = semanticModel.AllReferenceContainers
.OfType<OracleSelectListColumn>()
.SingleOrDefault(c => c.AliasNode == terminal);
if (selectListColumn != null)
{
multiNodeData.SynchronizedSegments = FindUsagesCommand.GetParentQueryBlockColumnUsages(selectListColumn)
.TakeWhile(t => String.Equals(t.Token.Value.ToQuotedIdentifier(), selectListColumn.NormalizedName))
.Select(t => t.SourcePosition)
.ToArray();
}
else
{
goto case Terminals.Identifier;
}
break;
case Terminals.Identifier:
multiNodeData.SynchronizedSegments = FindUsagesCommand.GetColumnUsages(semanticModel, terminal, true)
.Where(t => t != terminal)
.Select(t => t.SourcePosition)
.ToArray();
break;
}
return multiNodeData;
}
private BindVariableLiteralConversionCommand(ActionExecutionContext executionContext, BindVariableConfiguration bindVariable, bool allOccurences)
: base(executionContext)
{
_bindVariable = bindVariable;
_allOccurences = allOccurences;
}
private List<TextSegment> FindUsagesOrdered(string statementText, int currentPosition)
{
_documentRepository.UpdateStatements(statementText);
var executionContext = new ActionExecutionContext(statementText, currentPosition, currentPosition, 0, _documentRepository);
FindUsagesCommand.FindUsages.ExecutionHandler(executionContext);
return executionContext.SegmentsToReplace.OrderBy(s => s.IndextStart).ToList();
}
protected StatementFormatterBase(ActionExecutionContext executionContext)
{
ExecutionContext = executionContext;
}
private LiteralBindVariableConversionCommand(ActionExecutionContext executionContext, IReadOnlyList<StatementGrammarNode> literalTerminals, string requiredPrecedingTerminalId)
: base(executionContext)
{
_literalTerminals = literalTerminals;
_requiredPrecedingTerminalId = requiredPrecedingTerminalId;
}
public StatementNormalizer(ActionExecutionContext executionContext)
: base(executionContext)
{
}
private AddInsertIntoColumnListCommand(ActionExecutionContext executionContext)
: base(executionContext)
{
}
public SingleLineStatementFormatter(ActionExecutionContext executionContext)
: base(executionContext)
{
}
private ExpandAsteriskCommand(ActionExecutionContext executionContext)
: base(executionContext)
{
}
private GenerateCustomTypeCSharpWrapperClassCommand(ActionExecutionContext executionContext)
: base(executionContext)
{
}
