Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

chore: expand mssql completion omni coverage (#20182)

rebelice0d6bbafa8d57
diff --git a/backend/plugin/parser/tsql/completion.go b/backend/plugin/parser/tsql/completion.go
index 4ff670ba67..06117640c7 100644
--- a/backend/plugin/parser/tsql/completion.go
+++ b/backend/plugin/parser/tsql/completion.go
@@ -11,6 +11,7 @@ import (
"unicode/utf8"
"github.com/antlr4-go/antlr/v4"
+ omnimssql "github.com/bytebase/omni/mssql"
mssqlparser "github.com/bytebase/omni/mssql/parser"
tsqlparser "github.com/bytebase/parser/tsql"
@@ -24,8 +25,6 @@ func init() {
}
var (
- // Check tableRefListener is implementing the TSqlParserListener interface.
- _ tsqlparser.TSqlParserListener = &tableRefListener{}
_ tsqlparser.TSqlParserListener = &cteExtractor{}
tsqlDataTypes = []string{
@@ -454,17 +453,14 @@ type Completer struct {
metadataGetter base.GetDatabaseMetadataFunc
databaseNamesLister base.ListDatabaseNamesFunc
- cteCache map[int][]*base.VirtualTableReference
- // referencesStack is a hierarchical stack of table references.
- // We'll update the stack when we encounter a new FROM clauses.
- referencesStack [][]base.TableReference
// references is the flattened table references.
// It's helpful to look up the table reference.
- references []base.TableReference
- referenceMap map[string]bool
- cteTables []*base.VirtualTableReference
- caretTokenIsQuoted quotedType
- noSeparatorRequired map[int]bool
+ references []base.TableReference
+ referenceMap map[string]bool
+ cteTables []*base.VirtualTableReference
+ caretTokenIsQuoted quotedType
+ completionPrefix string
+ completionIntent *omnimssql.CompletionIntent
}
func Completion(ctx context.Context, cCtx base.CompletionContext, statement string, caretLine int, caretOffset int) ([]base.Candidate, error) {
@@ -514,7 +510,6 @@ func newCompleter(ctx context.Context, cCtx base.CompletionContext, parser *tsql
defaultSchema: "dbo",
metadataGetter: cCtx.Metadata,
databaseNamesLister: cCtx.ListDatabaseNames,
- cteCache: nil,
}
}
@@ -644,48 +639,104 @@ func (c *Completer) complete() ([]base.Candidate, error) {
}
}
- caretIndex := c.scanner.GetIndex()
- if caretIndex > 0 && !c.noSeparatorRequired[c.scanner.GetPreviousTokenType(true)] {
- caretIndex--
+ completionContext := omnimssql.CollectCompletion(c.sql, c.cursorByteOffset)
+ if completionContext != nil {
+ c.completionPrefix = completionContext.Prefix
+ c.completionIntent = completionContext.Intent
+ c.collectCompletionScopeReferences(completionContext)
+ c.collectCompletionCTEs(completionContext)
+ }
+ candidates := (*mssqlparser.CandidateSet)(nil)
+ if completionContext != nil {
+ candidates = completionContext.Candidates
+ }
+ if candidates == nil {
+ candidates = mssqlparser.Collect(c.sql, c.cursorByteOffset)
}
- c.referencesStack = append([][]base.TableReference{{}}, c.referencesStack...)
- completionOffset := c.cursorByteOffset
- candidates := mssqlparser.Collect(c.sql, completionOffset)
- if len(candidates.Rules) == 0 {
- if prefixTok, ok := c.prefixToken(); ok {
- completionOffset = prefixTok.Loc
- candidates = mssqlparser.Collect(c.sql, completionOffset)
+ return c.convertCandidates(candidates)
+}
+
+func (c *Completer) determineObjectNameContext() []*objectRefContext {
+ if c.completionIntent == nil {
+ return c.determineFullTableNameContext()
+ }
+ context := newObjectRefContext()
+ qualifier := c.completionIntent.Qualifier
+ if qualifier.Server != "" {
+ context.setLinkedServer(qualifier.Server)
+ }
+ if qualifier.Database != "" {
+ context.setDatabase(qualifier.Database)
+ }
+ if qualifier.Schema != "" {
+ context.setSchema(qualifier.Schema)
+ if qualifier.Database == "" {
+ context.flags &^= objectFlagShowDatabase
}
}
+ if qualifier.Object != "" {
+ context.setObject(qualifier.Object)
+ }
+ return []*objectRefContext{context}
+}
- for _, rc := range candidates.Rules {
- if rc.Rule == "columnref" {
- c.collectLeadingTableReferences(caretIndex)
- c.takeReferencesSnapshot()
- c.collectRemainingTableReferences()
- c.takeReferencesSnapshot()
- break
+func (c *Completer) determineColumnNameContext() []*objectRefContext {
+ if c.completionIntent == nil || !completionIntentHasObjectKind(c.completionIntent, omnimssql.ObjectKindColumn) {
+ return c.determineFullColumnName()
+ }
+ context := newObjectRefContext(withColumn())
+ qualifier := c.completionIntent.Qualifier
+ if qualifier.Database == "" && qualifier.Schema != "" && qualifier.Object == "" &&
+ (strings.EqualFold(qualifier.Schema, "INSERTED") || strings.EqualFold(qualifier.Schema, "DELETED")) {
+ return []*objectRefContext{context}
+ }
+ if qualifier.Object != "" {
+ if qualifier.Server != "" {
+ context.setLinkedServer(qualifier.Server)
+ }
+ if qualifier.Database != "" {
+ context.setDatabase(qualifier.Database)
}
+ if qualifier.Schema != "" {
+ context.setSchema(qualifier.Schema)
+ }
+ context.setObject(qualifier.Object)
+ context.flags &^= objectFlagShowDatabase | objectFlagShowSchema
+ return []*objectRefContext{context}
}
- return c.convertCandidates(candidates)
+ if qualifier.Server != "" && qualifier.Database != "" && qualifier.Schema != "" {
+ context.setDatabase(qualifier.Server)
+ context.setSchema(qualifier.Database)
+ context.setObject(qualifier.Schema)
+ context.flags &^= objectFlagShowDatabase | objectFlagShowSchema
+ return []*objectRefContext{context}
+ }
+ if qualifier.Schema != "" {
+ if qualifier.Database != "" {
+ context.setSchema(qualifier.Database)
+ }
+ context.setObject(qualifier.Schema)
+ context.flags &^= objectFlagShowDatabase | objectFlagShowSchema
+ return []*objectRefContext{context}
+ }
+ if qualifier.Database != "" {
+ context.setObject(qualifier.Database)
+ context.flags &^= objectFlagShowDatabase | objectFlagShowSchema
+ }
+ return []*objectRefContext{context}
}
-func (c *Completer) prefixToken() (mssqlparser.Token, bool) {
- idx := c.caretTokenIndex
- if idx < len(c.tokens) {
- tok := c.tokens[idx]
- if tok.Loc < c.cursorByteOffset && c.cursorByteOffset <= tok.End && mssqlparser.IsIdentTokenType(tok.Type) {
- return tok, true
- }
+func completionIntentHasObjectKind(intent *omnimssql.CompletionIntent, kind omnimssql.ObjectKind) bool {
+ if intent == nil {
+ return false
}
- if idx > 0 {
- tok := c.tokens[idx-1]
- if tok.End == c.cursorByteOffset && mssqlparser.IsIdentTokenType(tok.Type) {
- return tok, true
+ for _, objectKind := range intent.ObjectKinds {
+ if objectKind == kind {
+ return true
}
}
- return mssqlparser.Token{}, false
+ return false
}
func (c *Completer) convertCandidates(candidates *mssqlparser.CandidateSet) ([]base.Candidate, error) {
@@ -710,6 +761,8 @@ func (c *Completer) convertCandidates(candidates *mssqlparser.CandidateSet) ([]b
})
}
+ c.insertCompletionIntentCandidates(keywordEntries, functionEntries, databaseEntries, schemaEntries, tableEntries, viewEntries, sequenceEntries, routineEntries)
+
for _, ruleCandidate := range candidates.Rules {
c.scanner.PopAndRestore()
c.scanner.Push()
@@ -721,14 +774,14 @@ func (c *Completer) convertCandidates(candidates *mssqlparser.CandidateSet) ([]b
databaseEntries.insertMetadataDatabases(c, "")
case "schema_ref":
schemaEntries.insertMetadataSchemas(c, "", "")
- case "proc_ref":
- for _, context := range c.determineFullTableNameContext() {
+ case "proc_ref", "proc_name":
+ for _, context := range c.determineObjectNameContext() {
if context.flags&objectFlagShowObject != 0 {
routineEntries.insertMetadataProcedures(c, context.linkedServer, context.database, context.schema)
}
}
case "sequence_ref":
- for _, context := range c.determineFullTableNameContext() {
+ for _, context := range c.determineObjectNameContext() {
if context.flags&objectFlagShowObject != 0 {
sequenceEntries.insertMetadataSequences(c, context.linkedServer, context.database, context.schema)
}
@@ -741,17 +794,23 @@ func (c *Completer) convertCandidates(candidates *mssqlparser.CandidateSet) ([]b
})
}
case "table_ref":
- completionContexts := c.determineFullTableNameContext()
+ completionContexts := c.determineObjectNameContext()
for _, context := range completionContexts {
c.insertObjectCandidates(context, databaseEntries, schemaEntries, tableEntries, viewEntries, sequenceEntries)
}
+ case "view_name", "view_ref":
+ for _, context := range c.determineObjectNameContext() {
+ if context.flags&objectFlagShowObject != 0 {
+ viewEntries.insertMetadataViews(c, context.linkedServer, context.database, context.schema)
+ }
+ }
case "asterisk":
completionContexts := c.determineAsteriskContext()
for _, context := range completionContexts {
c.insertObjectCandidates(context, databaseEntries, schemaEntries, tableEntries, viewEntries, sequenceEntries)
}
case "columnref":
- completionContexts := c.determineFullColumnName()
+ completionContexts := c.determineColumnNameContext()
for _, context := range completionContexts {
c.insertObjectCandidates(context, databaseEntries, schemaEntries, tableEntries, viewEntries, sequenceEntries)
if context.flags&objectFlagShowObject != 0 {
@@ -793,10 +852,17 @@ func (c *Completer) convertCandidates(candidates *mssqlparser.CandidateSet) ([]b
})
}
}
- columnEntries.insertMetadataColumns(c, context.linkedServer, context.database, context.schema, context.object)
+ if !context.empty() || len(c.references) == 0 {
+ columnEntries.insertMetadataColumns(c, context.linkedServer, context.database, context.schema, context.object)
+ }
for _, reference := range c.references {
+ matchedQualifiedReference := false
switch reference := reference.(type) {
case *base.PhysicalTableReference:
+ if context.empty() {
+ columnEntries.insertMetadataColumns(c, "", reference.Database, reference.Schema, reference.Table)
+ continue
+ }
inputLinkedServer := context.linkedServer
inputDatabaseName := context.database
if inputDatabaseName == "" {
@@ -817,19 +883,26 @@ func (c *Completer) convertCandidates(candidates *mssqlparser.CandidateSet) ([]b
referenceSchemaName = c.defaultSchema
}
referenceTableName := reference.Table
+ referenceTableIsAlias := false
if reference.Alias != "" {
referenceTableName = reference.Alias
+ referenceTableIsAlias = true
}
- if inputLinkedServer == "" && strings.EqualFold(referenceDatabaseName, inputDatabaseName) &&
- strings.EqualFold(referenceSchemaName, inputSchemaName) &&
- strings.EqualFold(referenceTableName, inputTableName) {
+ if inputLinkedServer == "" && strings.EqualFold(referenceTableName, inputTableName) &&
+ (referenceTableIsAlias ||
+ (strings.EqualFold(referenceDatabaseName, inputDatabaseName) &&
+ strings.EqualFold(referenceSchemaName, inputSchemaName))) {
columnEntries.insertMetadataColumns(c, "", reference.Database, reference.Schema, reference.Table)
+ matchedQualifiedReference = referenceTableIsAlias && context.database == "" && context.schema == ""
}
case *base.VirtualTableReference:
// Reference could be a physical table reference or a virtual table reference, if the reference is a virtual table reference,
// and users do not specify the server, database and schema, we should also insert the columns.
if context.linkedServer == "" && context.database == "" && context.schema == "" {
+ if context.object != "" && !strings.EqualFold(reference.Table, context.object) {
+ continue
+ }
for _, column := range reference.Columns {
if _, ok := columnEntries[column]; !ok {
columnEntries[column] = base.Candidate{
@@ -838,9 +911,13 @@ func (c *Completer) convertCandidates(candidates *mssqlparser.CandidateSet) ([]b
}
}
}
+ matchedQualifiedReference = context.object != ""
}
default:
}
+ if matchedQualifiedReference {
+ break
+ }
}
if context.linkedServer == "" && context.database == "" && context.schema == "" {
for _, cte := range c.cteTables {
@@ -856,7 +933,7 @@ func (c *Completer) convertCandidates(candidates *mssqlparser.CandidateSet) ([]b
}
}
}
- if context.empty() {
+ if context.empty() && len(c.references) == 0 {
columnEntries.insertAllColumns(c)
}
}
@@ -879,7 +956,71 @@ func (c *Completer) convertCandidates(candidates *mssqlparser.CandidateSet) ([]b
result = append(result, viewEntries.toSlice()...)
result = append(result, sequenceEntries.toSlice()...)
result = append(result, routineEntries.toSlice()...)
- return result, nil
+ return c.filterCandidatesByPrefix(result), nil
+}
+
+func (c *Completer) insertCompletionIntentCandidates(keywordEntries, functionEntries, databaseEntries, schemaEntries, tableEntries, viewEntries, sequenceEntries, routineEntries CompletionMap) {
+ if c.completionIntent == nil {
+ return
+ }
+ contexts := c.determineObjectNameContext()
+ for _, kind := range c.completionIntent.ObjectKinds {
+ for _, context := range contexts {
+ switch kind {
+ case omnimssql.ObjectKindDatabase:
+ databaseEntries.insertMetadataDatabases(c, context.linkedServer)
+ case omnimssql.ObjectKindSchema:
+ schemaEntries.insertMetadataSchemas(c, context.linkedServer, context.database)
+ case omnimssql.ObjectKindTable:
+ if context.flags&objectFlagShowObject != 0 {
+ tableEntries.insertMetadataTables(c, context.linkedServer, context.database, context.schema)
+ }
+ case omnimssql.ObjectKindView:
+ if context.flags&objectFlagShowObject != 0 {
+ viewEntries.insertMetadataViews(c, context.linkedServer, context.database, context.schema)
+ }
+ case omnimssql.ObjectKindSequence:
+ if context.flags&objectFlagShowObject != 0 {
+ sequenceEntries.insertMetadataSequences(c, context.linkedServer, context.database, context.schema)
+ }
+ case omnimssql.ObjectKindProcedure:
+ if context.flags&objectFlagShowObject != 0 {
+ routineEntries.insertMetadataProcedures(c, context.linkedServer, context.database, context.schema)
+ }
+ case omnimssql.ObjectKindFunction:
+ functionEntries.insertBuiltinFunctions()
+ case omnimssql.ObjectKindType:
+ for _, typ := range tsqlDataTypes {
+ keywordEntries.Insert(base.Candidate{
+ Type: base.CandidateTypeKeyword,
+ Text: typ,
+ })
+ }
+ default:
+ }
+ }
+ }
+}
+
+func (c *Completer) filterCandidatesByPrefix(candidates []base.Candidate) []base.Candidate {
+ prefix := c.completionPrefix
+ if prefix == "" {
+ return candidates
+ }
+ _, normalizedPrefix := NormalizeTSQLIdentifierText(prefix)
+ if normalizedPrefix == "" {
+ return candidates
+ }
+ filtered := make([]base.Candidate, 0, len(candidates))
+ for _, candidate := range candidates {
+ text := strings.TrimSuffix(candidate.Text, "()")
+ text = unquoteDoubleQuoted(text)
+ _, normalizedText := NormalizeTSQLIdentifierText(text)
+ if strings.HasPrefix(normalizedText, normalizedPrefix) {
+ filtered = append(filtered, candidate)
+ }
+ }
+ return filtered
}
func (c *Completer) insertObjectCandidates(context *objectRefContext, databaseEntries, schemaEntries, tableEntries, viewEntries, sequenceEntries CompletionMap) {
@@ -1258,7 +1399,7 @@ func isDerivedTableOpen(upperSQL string, idx int) bool {
return false
}
before := strings.TrimRight(upperSQL[:idx], asciiWhitespace)
- for _, keyword := range []string{"FROM", "JOIN", "APPLY"} {
+ for _, keyword := range []string{"FROM", "JOIN", "APPLY", "USING"} {
if strings.HasSuffix(before, keyword) {
return true
}
@@ -1762,305 +1903,196 @@ func hasMultipleNonEmptyStatements(statements []base.Statement) bool {
return false
}
-func (c *Completer) takeReferencesSnapshot() {
- c.ensureReferenceMap()
- for _, references := range c.referencesStack {
- c.rememberReferences(references)
- }
-}
-
-func (c *Completer) ensureReferenceMap() {
- if c.referenceMap == nil {
- c.referenceMap = make(map[string]bool)
+func (c *Completer) collectCompletionScopeReferences(completionContext *omnimssql.CompletionContext) {
+ if completionContext == nil || completionContext.Scope == nil {
+ return
}
-}
-
-func (c *Completer) rememberReferences(references []base.TableReference) {
- c.references = append(c.references, references...)
- for _, reference := range references {
- physical, ok := reference.(*base.PhysicalTableReference)
- if !ok {
- continue
+ var references []base.TableReference
+ appendReference := func(reference omnimssql.RangeReference) {
+ if converted := c.convertCompletionScopeReference(reference); converted != nil {
+ references = append(references, converted)
}
- c.referenceMap[c.physicalReferenceKey(physical)] = true
}
-}
-
-func (c *Completer) physicalReferenceKey(reference *base.PhysicalTableReference) string {
- database := reference.Database
- if database == "" {
- database = c.defaultDatabase
+ if completionContext.Scope.DMLTarget != nil {
+ appendReference(*completionContext.Scope.DMLTarget)
}
- schema := reference.Schema
- if schema == "" {
- schema = c.defaultSchema
+ if completionContext.Scope.MergeTarget != nil {
+ appendReference(*completionContext.Scope.MergeTarget)
}
- return fmt.Sprintf("%s.%s.%s", database, schema, reference.Table)
-}
-
-func (c *Completer) collectLeadingTableReferences(caretIndex int) {
- c.scanner.Push()
-
- c.scanner.SeekIndex(0)
-
- level := 0
- for {
- found := c.scanner.GetTokenType() == tsqlparser.TSqlLexerFROM
- for !found {
- if !c.scanner.Forward(false) || c.scanner.GetIndex() >= caretIndex {
- break
- }
-
- switch c.scanner.GetTokenType() {
- case tsqlparser.TSqlLexerLR_BRACKET:
- level++
- c.referencesStack = append([][]base.TableReference{{}}, c.referencesStack...)
- case tsqlparser.TSqlLexerRR_BRACKET:
- if level == 0 {
- c.scanner.PopAndRestore()
- return // We cannot go above the initial nesting level.
- }
- case tsqlparser.TSqlLexerFROM:
- found = true
- default:
- // Other tokens, continue scanning
- }
- }
- if !found {
- c.scanner.PopAndRestore()
- return // No FROM clause found.
- }
- c.parseTableReferences(c.scanner.GetFollowingText())
- if c.scanner.GetTokenType() == tsqlparser.TSqlLexerFROM {
- c.scanner.Forward(false /* skipHidden */)
- }
+ if completionContext.Scope.MergeSource != nil {
+ appendReference(*completionContext.Scope.MergeSource)
}
-}
-
-func (c *Completer) collectRemainingTableReferences() {
- c.scanner.Push()
-
- level := 0
- for {
- found := c.scanner.GetTokenType() == tsqlparser.TSqlLexerFROM
- for !found {
- if !c.scanner.Forward(false /* skipHidden */) {
- break
- }
-
- switch c.scanner.GetTokenType() {
- case tsqlparser.TSqlLexerLR_BRACKET:
- level++
- c.referencesStack = append([][]base.TableReference{{}}, c.referencesStack...)
- case tsqlparser.TSqlLexerRR_BRACKET:
- if level > 0 {
- level--
- }
-
- case tsqlparser.TSqlLexerFROM:
- if level == 0 {
- found = true
- }
- default:
- // Other tokens, continue scanning
- }
- }
-
- if !found {
- c.scanner.PopAndRestore()
- return // No more FROM clause found.
- }
-
- c.parseTableReferences(c.scanner.GetFollowingText())
- if c.scanner.GetTokenType() == tsqlparser.TSqlLexerFROM {
- c.scanner.Forward(false /* skipHidden */)
- }
+ for _, reference := range completionContext.Scope.LocalReferences {
+ appendReference(reference)
}
-}
-
-func (c *Completer) parseTableReferences(fromClause string) {
- input := antlr.NewInputStream(fromClause)
- lexer := tsqlparser.NewTSqlLexer(input)
- tokens := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)
- parser := tsqlparser.NewTSqlParser(tokens)
-
- parser.BuildParseTrees = true
- parser.RemoveErrorListeners()
- tree := parser.From_table_sources()
- listener := &tableRefListener{
- context: c,
- fromClauseMode: true,
+ for _, level := range completionContext.Scope.OuterReferences {
+ for _, reference := range level {
+ appendReference(reference)
+ }
}
- antlr.ParseTreeWalkerDefault.Walk(listener, tree)
-}
-
-type tableRefListener struct {
- *tsqlparser.BaseTSqlParserListener
-
- context *Completer
- fromClauseMode bool
- done bool
- level int
+ c.rememberReferencesIfMissing(references)
}
-func (l *tableRefListener) ExitAs_table_alias(ctx *tsqlparser.As_table_aliasContext) {
- if l.done {
+func (c *Completer) collectCompletionCTEs(completionContext *omnimssql.CompletionContext) {
+ if completionContext == nil {
return
}
- if l.level == 0 && len(l.context.referencesStack) != 0 && len(l.context.referencesStack[0]) != 0 {
- if physicalTable, ok := l.context.referencesStack[0][len(l.context.referencesStack[0])-1].(*base.PhysicalTableReference); ok {
- physicalTable.Alias = unquote(ctx.Table_alias().GetText())
- return
- }
- if virtualTable, ok := l.context.referencesStack[0][len(l.context.referencesStack[0])-1].(*base.VirtualTableReference); ok {
- virtualTable.Table = unquote(ctx.Table_alias().GetText())
+ for _, reference := range completionContext.CTEs {
+ virtual := c.convertCompletionVirtualReference(reference)
+ if virtual == nil {
+ continue
}
+ c.appendCTEIfMissing(virtual)
}
}
-func (l *tableRefListener) ExitColumn_alias_list(ctx *tsqlparser.Column_alias_listContext) {
- if l.done {
- return
- }
-
- if l.level == 0 && len(l.context.referencesStack) != 0 && len(l.context.referencesStack[0]) != 0 {
- if virtualTable, ok := l.context.referencesStack[0][len(l.context.referencesStack[0])-1].(*base.VirtualTableReference); ok {
- var newColumns []string
- for _, column := range ctx.AllColumn_alias() {
- newColumns = append(newColumns, unquote(column.GetText()))
+func (c *Completer) appendCTEIfMissing(reference *base.VirtualTableReference) {
+ for _, existing := range c.cteTables {
+ if strings.EqualFold(existing.Table, reference.Table) {
+ if len(existing.Columns) == 0 && len(reference.Columns) > 0 {
+ existing.Columns = reference.Columns
}
- virtualTable.Columns = newColumns
+ return
}
}
+ c.cteTables = append(c.cteTables, reference)
}
-func (l *tableRefListener) ExitFull_table_name(ctx *tsqlparser.Full_table_nameContext) {
- if l.done {
- return
- }
-
- if !l.fromClauseMode || l.level == 0 {
- reference := &base.PhysicalTableReference{}
- _ /* Linked Server */, database, schema, table := normalizeFullTableNameFallback(ctx, "", "")
- reference.Database = database
- reference.Schema = schema
- reference.Table = table
- l.context.referencesStack[0] = append(l.context.referencesStack[0], reference)
+func (c *Completer) rememberReferencesIfMissing(references []base.TableReference) {
+ c.ensureReferenceMap()
+ for _, reference := range references {
+ if c.hasReference(reference) {
+ continue
+ }
+ c.rememberReferences([]base.TableReference{reference})
}
}
-func (l *tableRefListener) ExitRowset_function(*tsqlparser.Rowset_functionContext) {
- if l.done {
- return
- }
-
- if !l.fromClauseMode || l.level == 0 {
- reference := &base.VirtualTableReference{}
-
- l.context.referencesStack[0] = append(l.context.referencesStack[0], reference)
+func (c *Completer) hasReference(reference base.TableReference) bool {
+ key := completionTableReferenceKey(reference)
+ for _, existing := range c.references {
+ if completionTableReferenceKey(existing) == key {
+ return true
+ }
}
+ return false
}
-func (l *tableRefListener) ExitDerivedTable(ctx *tsqlparser.Derived_tableContext) {
- if l.done {
- return
- }
-
- pCtx, ok := ctx.GetParent().(*tsqlparser.Table_source_itemContext)
- if !ok {
- return
- }
-
- derivedTableName := unquote(pCtx.As_table_alias().Table_alias().GetText())
- reference := &base.VirtualTableReference{
- Table: derivedTableName,
+func completionTableReferenceKey(reference base.TableReference) string {
+ switch reference := reference.(type) {
+ case *base.PhysicalTableReference:
+ return strings.Join([]string{"physical", reference.Database, reference.Schema, reference.Table, reference.Alias}, "\x00")
+ case *base.VirtualTableReference:
+ return strings.Join([]string{"virtual", reference.Table}, "\x00")
+ default:
+ return fmt.Sprintf("%T", reference)
}
+}
- if pCtx.Column_alias_list() == nil {
- // User do not specify the column alias, we should use query span to get the column alias.
- if span, err := GetQuerySpan(
- l.context.ctx,
- base.GetQuerySpanContext{
- InstanceID: l.context.instanceID,
- GetDatabaseMetadataFunc: l.context.metadataGetter,
- ListDatabaseNamesFunc: l.context.databaseNamesLister,
- },
- base.Statement{Text: fmt.Sprintf("SELECT * FROM (%s);", ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx))},
- l.context.defaultDatabase,
- l.context.defaultSchema,
- true,
- ); err == nil && span.NotFoundError == nil {
- for _, column := range span.Results {
- reference.Columns = append(reference.Columns, column.Name)
+func (c *Completer) convertCompletionScopeReference(reference omnimssql.RangeReference) base.TableReference {
+ switch reference.Kind {
+ case omnimssql.RangeReferenceRelation, omnimssql.RangeReferenceDMLTarget, omnimssql.RangeReferenceMergeTarget, omnimssql.RangeReferenceMergeSource:
+ alias := normalizeCompletionIdentifier(reference.Alias)
+ if reference.Kind == omnimssql.RangeReferenceMergeSource {
+ table := normalizeCompletionIdentifier(reference.Object)
+ if columns := c.lookupCTEColumns(table); len(columns) > 0 {
+ if alias != "" {
+ table = alias
+ }
+ return &base.VirtualTableReference{
+ Table: table,
+ Columns: columns,
+ }
}
}
+ return &base.PhysicalTableReference{
+ Database: normalizeCompletionIdentifier(reference.Database),
+ Schema: normalizeCompletionIdentifier(reference.Schema),
+ Table: normalizeCompletionIdentifier(reference.Object),
+ Alias: alias,
+ }
+ case omnimssql.RangeReferenceCTE, omnimssql.RangeReferenceValues, omnimssql.RangeReferenceSubquery, omnimssql.RangeReferenceTableVariable, omnimssql.RangeReferenceJoinAlias, omnimssql.RangeReferenceFunction:
+ return c.convertCompletionVirtualReference(reference)
+ default:
+ return nil
}
- l.context.referencesStack[0] = append(l.context.referencesStack[0], reference)
}
-func (l *tableRefListener) ExitChange_table(*tsqlparser.Change_tableContext) {
- if l.done {
- return
+func (c *Completer) convertCompletionVirtualReference(reference omnimssql.RangeReference) *base.VirtualTableReference {
+ table := completionReferenceName(reference)
+ if table == "" {
+ return nil
}
-
- if !l.fromClauseMode || l.level == 0 {
- reference := &base.VirtualTableReference{}
- l.context.referencesStack[0] = append(l.context.referencesStack[0], reference)
+ columns := completionReferenceColumns(reference)
+ if len(columns) == 0 && reference.Kind == omnimssql.RangeReferenceCTE {
+ columns = c.lookupCTEColumns(table)
+ }
+ return &base.VirtualTableReference{
+ Table: table,
+ Columns: columns,
}
}
-func (l *tableRefListener) ExitNodes_method(*tsqlparser.Nodes_methodContext) {
- if l.done {
- return
+func completionReferenceName(reference omnimssql.RangeReference) string {
+ if reference.Alias != "" {
+ return normalizeCompletionIdentifier(reference.Alias)
}
+ return normalizeCompletionIdentifier(reference.Object)
+}
- if !l.fromClauseMode || l.level == 0 {
- reference := &base.VirtualTableReference{}
- l.context.referencesStack[0] = append(l.context.referencesStack[0], reference)
+func completionReferenceColumns(reference omnimssql.RangeReference) []string {
+ columns := reference.Columns
+ if len(columns) == 0 {
+ columns = reference.AliasColumns
+ }
+ result := make([]string, 0, len(columns))
+ for _, column := range columns {
+ result = append(result, normalizeCompletionIdentifier(column))
}
+ return result
}
-func (l *tableRefListener) EnterTable_source_item(ctx *tsqlparser.Table_source_itemContext) {
- if l.done {
- return
- }
+func normalizeCompletionIdentifier(identifier string) string {
+ original, _ := NormalizeTSQLIdentifierText(unquoteDoubleQuoted(identifier))
+ return original
+}
- if !l.fromClauseMode || l.level == 0 {
- if ctx.GetLoc_id() != nil {
- reference := &base.VirtualTableReference{}
- l.context.referencesStack[0] = append(l.context.referencesStack[0], reference)
- } else if ctx.GetLoc_id_call() != nil {
- reference := &base.VirtualTableReference{}
- l.context.referencesStack[0] = append(l.context.referencesStack[0], reference)
- } else if ctx.GetOldstyle_fcall() != nil {
- reference := &base.VirtualTableReference{}
- l.context.referencesStack[0] = append(l.context.referencesStack[0], reference)
+func (c *Completer) lookupCTEColumns(table string) []string {
+ for _, cte := range c.cteTables {
+ if strings.EqualFold(cte.Table, table) {
+ return cte.Columns
}
}
+ return nil
}
-func (l *tableRefListener) EnterSubquery(*tsqlparser.SubqueryContext) {
- if l.done {
- return
+func (c *Completer) ensureReferenceMap() {
+ if c.referenceMap == nil {
+ c.referenceMap = make(map[string]bool)
}
+}
- if l.fromClauseMode {
- l.level++
- } else {
- l.context.referencesStack = append([][]base.TableReference{{}}, l.context.referencesStack...)
+func (c *Completer) rememberReferences(references []base.TableReference) {
+ c.references = append(c.references, references...)
+ for _, reference := range references {
+ physical, ok := reference.(*base.PhysicalTableReference)
+ if !ok {
+ continue
+ }
+ c.referenceMap[c.physicalReferenceKey(physical)] = true
}
}
-func (l *tableRefListener) ExitSubquery(*tsqlparser.SubqueryContext) {
- if l.done {
- return
+func (c *Completer) physicalReferenceKey(reference *base.PhysicalTableReference) string {
+ database := reference.Database
+ if database == "" {
+ database = c.defaultDatabase
}
-
- if l.fromClauseMode {
- l.level--
- } else {
- l.context.referencesStack = l.context.referencesStack[1:]
+ schema := reference.Schema
+ if schema == "" {
+ schema = c.defaultSchema
}
+ return fmt.Sprintf("%s.%s.%s", database, schema, reference.Table)
}
func (c *Completer) fetchCommonTableExpression(statement string) {
diff --git a/backend/plugin/parser/tsql/completion_matrix_test.go b/backend/plugin/parser/tsql/completion_matrix_test.go
index e943a80fc5..b4f04c6de5 100644
--- a/backend/plugin/parser/tsql/completion_matrix_test.go
+++ b/backend/plugin/parser/tsql/completion_matrix_test.go
@@ -51,6 +51,14 @@ func TestCompletionCoverageMatrix(t *testing.T) {
sql: "SELECT e.Na| FROM Employees AS e",
want: columns("Name"),
},
+ {
+ name: "cross database qualified column reference",
+ sql: "SELECT School.dbo.Student.|",
+ want: columns("Id", "ParentName"),
+ notWant: columns(
+ "Name",
+ ),
+ },
{
name: "where clause uses current table columns",
sql: "SELECT * FROM Employees WHERE |",
@@ -98,11 +106,66 @@ func TestCompletionCoverageMatrix(t *testing.T) {
sql: "SELECT * FROM Employees WHERE Id IN (|)",
want: columns("Id", "Name"),
},
+ {
+ name: "in expression after comma uses current table columns",
+ sql: "SELECT * FROM Employees WHERE Id IN (1, |)",
+ want: columns("Id", "Name"),
+ },
+ {
+ name: "or predicate uses current table columns",
+ sql: "SELECT * FROM Employees WHERE Id = 1 OR |",
+ want: columns("Id", "Name"),
+ },
+ {
+ name: "and predicate after is null uses current table columns",
+ sql: "SELECT * FROM Employees WHERE Id IS NULL AND |",
+ want: columns("Id", "Name"),
+ },
+ {
+ name: "not predicate uses current table columns",
+ sql: "SELECT * FROM Employees WHERE NOT |",
+ want: columns("Id", "Name"),
+ },
+ {
+ name: "comparison expression uses current table columns",
+ sql: "SELECT * FROM Employees WHERE Id > |",
+ want: columns("Id", "Name"),
+ },
+ {
+ name: "qualified comparison expression uses alias columns",
+ sql: "SELECT * FROM Employees e WHERE e.Id = |",
+ want: columns("Id", "Name"),
+ },
+ {
+ name: "arithmetic expression uses current table columns",
+ sql: "SELECT * FROM Employees WHERE Id + | > 0",
+ want: columns("Id", "Name"),
+ },
+ {
+ name: "between upper bound uses current table columns",
+ sql: "SELECT * FROM Employees WHERE Id BETWEEN 1 AND |",
+ want: columns("Id", "Name"),
+ },
+ {
+ name: "parenthesized predicate uses current table columns",
+ sql: "SELECT * FROM Employees WHERE (|)",
+ want: columns("Id", "Name"),
+ },
{
name: "case predicate uses current table columns",
sql: "SELECT CASE WHEN | THEN 1 ELSE 0 END FROM Employees",
want: columns("Id", "Name"),
},
+ {
+ name: "case then expression uses current table columns",
+ sql: "SELECT CASE WHEN Id > 0 THEN | ELSE 0 END FROM Employees",
+ want: columns("Id", "Name"),
+ },
+ {
+ name: "case else expression uses current table columns",
+ sql: "SELECT CASE WHEN Id > 0 THEN 1 ELSE | END FROM Employees",
+ want: columns("Id", "Name"),
+ },
{
name: "function argument uses current table columns",
sql: "SELECT COUNT(|) FROM Employees",
@@ -113,6 +176,41 @@ func TestCompletionCoverageMatrix(t *testing.T) {
sql: "SELECT ABS(|) FROM Employees",
want: columns("Id", "Name"),
},
+ {
+ name: "nested function argument uses current table columns",
+ sql: "SELECT ABS(ROUND(|, 0)) FROM Employees",
+ want: columns("Id", "Name"),
+ },
+ {
+ name: "isnull argument uses current table columns",
+ sql: "SELECT ISNULL(|, 0) FROM Employees",
+ want: columns("Id", "Name"),
+ },
+ {
+ name: "coalesce argument uses current table columns",
+ sql: "SELECT COALESCE(NULL, |) FROM Employees",
+ want: columns("Id", "Name"),
+ },
+ {
+ name: "nullif argument uses current table columns",
+ sql: "SELECT NULLIF(|, 0) FROM Employees",
+ want: columns("Id", "Name"),
+ },
+ {
+ name: "cast argument uses current table columns",
+ sql: "SELECT CAST(| AS INT) FROM Employees",
+ want: columns("Id", "Name"),
+ },
+ {
+ name: "convert argument uses current table columns",
+ sql: "SELECT CONVERT(INT, |) FROM Employees",
+ want: columns("Id", "Name"),
+ },
+ {
+ name: "iif predicate uses current table columns",
+ sql: "SELECT IIF(|, 1, 0) FROM Employees",
+ want: columns("Id", "Name"),
+ },
{
name: "order by includes select alias",
sql: "SELECT Id AS IdAlias, Name FROM Employees ORDER BY |",
@@ -123,6 +221,16 @@ func TestCompletionCoverageMatrix(t *testing.T) {
sql: "SELECT IdAlias = Id, Name FROM Employees ORDER BY |",
want: append(columns("Id", "Name"), column("IdAlias")),
},
+ {
+ name: "order by alias prefix keeps select alias available",
+ sql: "SELECT Id AS IdAlias, Name FROM Employees ORDER BY IdA|",
+ want: columns("IdAlias"),
+ },
+ {
+ name: "order by column prefix keeps matching column available",
+ sql: "SELECT * FROM Employees ORDER BY Na|",
+ want: columns("Name"),
+ },
{
name: "top select list uses columns",
sql: "SELECT TOP 10 | FROM Employees",
@@ -138,11 +246,21 @@ func TestCompletionCoverageMatrix(t *testing.T) {
sql: "SELECT ROW_NUMBER() OVER (PARTITION BY |) FROM Employees",
want: columns("Id", "Name"),
},
+ {
+ name: "window partition by uses qualified alias columns",
+ sql: "SELECT ROW_NUMBER() OVER (PARTITION BY e.| ORDER BY e.Id) FROM Employees e",
+ want: columns("Id", "Name"),
+ },
{
name: "window order by uses columns",
sql: "SELECT ROW_NUMBER() OVER (ORDER BY |) FROM Employees",
want: columns("Id", "Name"),
},
+ {
+ name: "window order by uses qualified alias columns",
+ sql: "SELECT ROW_NUMBER() OVER (PARTITION BY e.Id ORDER BY e.|) FROM Employees e",
+ want: columns("Id", "Name"),
+ },
{
name: "window order by excludes select alias",
sql: "SELECT Id AS IdAlias, ROW_NUMBER() OVER (ORDER BY |) FROM Employees",
@@ -170,6 +288,11 @@ func TestCompletionCoverageMatrix(t *testing.T) {
sql: "SELECT * FROM Employees e ORDER BY e.| OFFSET 10 ROWS",
want: columns("Id", "Name"),
},
+ {
+ name: "offset fetch order by keeps alias columns",
+ sql: "SELECT * FROM Employees e ORDER BY e.| OFFSET 10 ROWS FETCH NEXT 5 ROWS ONLY",
+ want: columns("Id", "Name"),
+ },
{
name: "join table reference",
sql: "SELECT * FROM Employees JOIN |",
@@ -236,6 +359,29 @@ func TestCompletionCoverageMatrix(t *testing.T) {
sql: "SELECT * FROM Employees e JOIN Address a ON e.Id = a.EmployeeId JOIN MySchema.SalaryLevel s ON e.Id = s.Id WHERE |",
want: columns("Id", "Name", "EmployeeId", "Street", "SalaryUpBound"),
},
+ {
+ name: "cross join where uses right alias columns",
+ sql: "SELECT * FROM Employees e CROSS JOIN Address a WHERE a.|",
+ want: columns("EmployeeId", "Street"),
+ },
+ {
+ name: "schema qualified join on uses right alias columns",
+ sql: "SELECT * FROM Employees e LEFT JOIN MySchema.SalaryLevel s ON s.|",
+ want: columns("Id", "SalaryUpBound"),
+ },
+ {
+ name: "joined order by uses right alias columns",
+ sql: "SELECT * FROM Employees e JOIN Address a ON e.Id = a.EmployeeId ORDER BY a.|",
+ want: columns("EmployeeId", "Street"),
+ notWant: columns(
+ "Name",
+ ),
+ },
+ {
+ name: "joined group by uses right alias columns",
+ sql: "SELECT a.EmployeeId, COUNT(*) FROM Employees e JOIN Address a ON e.Id = a.EmployeeId GROUP BY a.|",
+ want: columns("EmployeeId", "Street"),
+ },
{
name: "default schema table reference",
sql: "SELECT * FROM |",
@@ -267,11 +413,26 @@ func TestCompletionCoverageMatrix(t *testing.T) {
"Employees",
),
},
+ {
+ name: "database qualified dbo table reference",
+ sql: "SELECT * FROM Company.dbo.|",
+ want: tables("Address", "Employees"),
+ },
+ {
+ name: "database qualified alternate schema table reference",
+ sql: "SELECT * FROM Company.MySchema.|",
+ want: tables("SalaryLevel"),
+ },
{
name: "bracket quoted schema table reference",
sql: "SELECT * FROM [dbo].|",
want: tables("Address", "Employees"),
},
+ {
+ name: "bracket quoted table alias columns",
+ sql: "SELECT * FROM [dbo].[Employees] AS [emp] WHERE [emp].|",
+ want: columns("Id", "Name"),
+ },
{
name: "schema qualified table prefix keeps matching table available",
sql: "SELECT * FROM dbo.Emp|",
@@ -315,6 +476,21 @@ func TestCompletionCoverageMatrix(t *testing.T) {
sql: "WITH cte AS (SELECT Id, Name FROM Employees) SELECT | FROM cte",
want: columns("Id", "Name"),
},
+ {
+ name: "cte qualified projected columns are available",
+ sql: "WITH cte AS (SELECT Id, Name FROM Employees) SELECT cte.| FROM cte",
+ want: columns("Id", "Name"),
+ },
+ {
+ name: "cte where uses projected columns",
+ sql: "WITH cte AS (SELECT Id, Name FROM Employees) SELECT * FROM cte WHERE |",
+ want: columns("Id", "Name"),
+ },
+ {
+ name: "cte insert select uses projected columns",
+ sql: "WITH cte AS (SELECT Id, Name FROM Employees) INSERT INTO Employees SELECT | FROM cte",
+ want: columns("Id", "Name"),
+ },
{
name: "chained cte table is available",
sql: "WITH a AS (SELECT Id FROM Employees), b AS (SELECT Id FROM a) SELECT * FROM |",
@@ -325,21 +501,93 @@ func TestCompletionCoverageMatrix(t *testing.T) {
sql: "SELECT * FROM Employees WHERE EXISTS (SELECT | FROM Address)",
want: columns("EmployeeId", "Street"),
},
+ {
+ name: "subquery where uses inner table columns",
+ sql: "SELECT * FROM Employees WHERE EXISTS (SELECT 1 FROM Address WHERE |)",
+ want: columns("EmployeeId", "Street"),
+ },
+ {
+ name: "in subquery select list uses inner table columns",
+ sql: "SELECT * FROM Employees WHERE Id IN (SELECT | FROM Address)",
+ want: columns("EmployeeId", "Street"),
+ },
+ {
+ name: "apply subquery select list uses inner table columns",
+ sql: "SELECT * FROM Employees e CROSS APPLY (SELECT | FROM Address) x",
+ want: columns("EmployeeId", "Street"),
+ },
+ {
+ name: "scalar subquery select list uses inner table columns",
+ sql: "SELECT (SELECT | FROM Employees) FROM Address",
+ want: columns("Id", "Name"),
+ },
+ {
+ name: "aggregate scalar subquery uses inner table columns",
+ sql: "SELECT * FROM Employees WHERE Id = (SELECT MAX(|) FROM Address)",
+ want: columns("EmployeeId", "Street"),
+ },
{
name: "derived table alias columns",
sql: "SELECT d.| FROM (SELECT Id, Name FROM Employees) d",
want: columns("Id", "Name"),
},
+ {
+ name: "nested derived table alias columns",
+ sql: "SELECT x.| FROM (SELECT d.Id FROM (SELECT Id FROM Employees) d) x",
+ want: columns("Id"),
+ },
+ {
+ name: "values derived table alias columns",
+ sql: "SELECT v.| FROM (VALUES (1, 'a')) AS v(Id, ValueLabel)",
+ want: columns("Id", "ValueLabel"),
+ },
{
name: "correlated subquery can complete outer alias",
sql: "SELECT * FROM Employees e WHERE EXISTS (SELECT 1 FROM Address a WHERE a.EmployeeId = e.|)",
want: columns("Id", "Name"),
},
+ {
+ name: "correlated subquery can complete inner alias",
+ sql: "SELECT * FROM Employees e WHERE EXISTS (SELECT 1 FROM Address a WHERE a.| = e.Id)",
+ want: columns("EmployeeId", "Street"),
+ },
+ {
+ name: "inner alias shadows outer alias",
+ sql: "SELECT * FROM Employees o WHERE EXISTS (SELECT 1 FROM Address o WHERE o.| = 1)",
+ want: columns("EmployeeId", "Street"),
+ notWant: columns(
+ "Name",
+ ),
+ },
+ {
+ name: "any subquery select list uses inner table columns",
+ sql: "SELECT * FROM Employees WHERE Id = ANY (SELECT | FROM Address)",
+ want: columns("EmployeeId", "Street"),
+ },
+ {
+ name: "all subquery select list uses inner table columns",
+ sql: "SELECT * FROM Employees WHERE Id > ALL (SELECT | FROM Address)",
+ want: columns("EmployeeId", "Street"),
+ },
{
name: "union right arm uses right table columns",
sql: "SELECT Id FROM Employees UNION SELECT | FROM Address",
want: columns("EmployeeId", "Street"),
},
+ {
+ name: "union all right arm uses right table columns",
+ sql: "SELECT Id FROM Employees UNION ALL SELECT | FROM Address",
+ want: columns("EmployeeId", "Street"),
+ },
+ {
+ name: "chained union final arm uses final table columns",
+ sql: "SELECT Id FROM Employees UNION SELECT EmployeeId FROM Address UNION SELECT | FROM MySchema.SalaryLevel",
+ want: columns("Id", "SalaryUpBound"),
+ notWant: columns(
+ "EmployeeId",
+ "Street",
+ ),
+ },
{
name: "except right arm uses right table columns",
sql: "SELECT Id FROM Employees EXCEPT SELECT | FROM Address",
@@ -360,11 +608,34 @@ func TestCompletionCoverageMatrix(t *testing.T) {
sql: "INSERT INTO dbo.|",
want: tables("Address", "Employees"),
},
+ {
+ name: "insert target cross database table reference",
+ sql: "INSERT INTO School.dbo.|",
+ want: tables("Student"),
+ notWant: tables(
+ "Employees",
+ ),
+ },
+ {
+ name: "insert target alternate schema table reference",
+ sql: "INSERT INTO MySchema.|",
+ want: tables("SalaryLevel"),
+ },
{
name: "insert column list uses target columns",
sql: "INSERT INTO Employees(|) VALUES (1)",
want: columns("Id", "Name"),
},
+ {
+ name: "insert schema qualified column list uses target columns",
+ sql: "INSERT INTO dbo.Employees(|) VALUES (1)",
+ want: columns("Id", "Name"),
+ },
+ {
+ name: "insert cross database column list uses target columns",
+ sql: "INSERT INTO School.dbo.Student(|) VALUES (1)",
+ want: columns("Id", "ParentName"),
+ },
{
name: "insert column list after comma uses remaining target columns",
sql: "INSERT INTO Employees(Id, |) VALUES (1, 'a')",
@@ -396,11 +667,21 @@ func TestCompletionCoverageMatrix(t *testing.T) {
sql: "UPDATE dbo.| SET Name = 'a'",
want: tables("Address", "Employees"),
},
+ {
+ name: "update target cross database table reference",
+ sql: "UPDATE School.dbo.| SET ParentName = 'a'",
+ want: tables("Student"),
+ },
{
name: "update set column uses target columns",
sql: "UPDATE Employees SET |",
want: columns("Id", "Name"),
},
+ {
+ name: "update cross database set column uses target columns",
+ sql: "UPDATE School.dbo.Student SET |",
+ want: columns("Id", "ParentName"),
+ },
{
name: "update where uses target columns",
sql: "UPDATE Employees SET Name = 'a' WHERE |",
@@ -411,6 +692,26 @@ func TestCompletionCoverageMatrix(t *testing.T) {
sql: "UPDATE Employees SET Name = |",
want: columns("Id", "Name"),
},
+ {
+ name: "update top target table reference",
+ sql: "UPDATE TOP (10) | SET Name = 'a'",
+ want: tables("Address", "Employees"),
+ },
+ {
+ name: "update alias set column uses target columns",
+ sql: "UPDATE e SET | FROM Employees e",
+ want: columns("Id", "Name"),
+ },
+ {
+ name: "update alias set value uses target columns",
+ sql: "UPDATE e SET Name = | FROM Employees e",
+ want: columns("Id", "Name"),
+ },
+ {
+ name: "update joined set value uses joined alias columns",
+ sql: "UPDATE e SET Name = a.| FROM Employees e JOIN Address a ON e.Id = a.EmployeeId",
+ want: columns("EmployeeId", "Street"),
+ },
{
name: "update from joined alias columns",
sql: "UPDATE e SET Name = 'x' FROM Employees e JOIN Address a ON e.Id = a.EmployeeId WHERE a.|",
@@ -436,16 +737,36 @@ func TestCompletionCoverageMatrix(t *testing.T) {
sql: "DELETE FROM dbo.|",
want: tables("Address", "Employees"),
},
+ {
+ name: "delete target cross database table reference",
+ sql: "DELETE FROM School.dbo.|",
+ want: tables("Student"),
+ },
+ {
+ name: "delete top target table reference",
+ sql: "DELETE TOP (10) FROM |",
+ want: tables("Address", "Employees"),
+ },
{
name: "delete where uses target columns",
sql: "DELETE FROM Employees WHERE |",
want: columns("Id", "Name"),
},
+ {
+ name: "delete cross database where uses target columns",
+ sql: "DELETE FROM School.dbo.Student WHERE |",
+ want: columns("Id", "ParentName"),
+ },
{
name: "delete alias where uses target columns",
sql: "DELETE e FROM Employees e WHERE e.|",
want: columns("Id", "Name"),
},
+ {
+ name: "delete joined alias where uses joined columns",
+ sql: "DELETE e FROM Employees e JOIN Address a ON e.Id = a.EmployeeId WHERE a.|",
+ want: columns("EmployeeId", "Street"),
+ },
{
name: "delete output deleted columns",
sql: "DELETE FROM Employees OUTPUT DELETED.|",
@@ -456,6 +777,11 @@ func TestCompletionCoverageMatrix(t *testing.T) {
sql: "CREATE INDEX ix ON |",
want: tables("Address", "Employees"),
},
+ {
+ name: "create index target schema table reference",
+ sql: "CREATE INDEX ix ON dbo.|",
+ want: tables("Address", "Employees"),
+ },
{
name: "create index column list uses target columns",
sql: "CREATE INDEX ix ON Employees(|)",
@@ -466,21 +792,54 @@ func TestCompletionCoverageMatrix(t *testing.T) {
"Street",
),
},
+ {
+ name: "create index schema qualified column list uses target columns",
+ sql: "CREATE INDEX ix ON dbo.Employees(|)",
+ want: columns("Id", "Name"),
+ },
+ {
+ name: "create unique clustered index column list uses target columns",
+ sql: "CREATE UNIQUE CLUSTERED INDEX ix ON Employees(|)",
+ want: columns("Id", "Name"),
+ },
+ {
+ name: "create index include column list uses target columns",
+ sql: "CREATE INDEX ix ON Employees(Id) INCLUDE (|)",
+ want: columns("Id", "Name"),
+ },
{
name: "create view body select uses source columns",
sql: "CREATE VIEW v AS SELECT | FROM Employees",
want: columns("Id", "Name"),
},
+ {
+ name: "create view with schema body select uses source columns",
+ sql: "CREATE VIEW MySchema.v AS SELECT | FROM Employees",
+ want: columns("Id", "Name"),
+ },
{
name: "create procedure body select uses source columns",
sql: "CREATE PROCEDURE p AS SELECT | FROM Employees",
want: columns("Id", "Name"),
},
+ {
+ name: "create procedure parameter type name",
+ sql: "CREATE PROCEDURE p @Name | AS SELECT 1",
+ want: keywords("INT", "NVARCHAR"),
+ },
{
name: "create table references table",
sql: "CREATE TABLE NewTable (EmployeeId INT REFERENCES |)",
want: tables("Address", "Employees"),
},
+ {
+ name: "create table references cross database table",
+ sql: "CREATE TABLE NewTable (StudentId INT REFERENCES School.dbo.|)",
+ want: tables("Student"),
+ notWant: tables(
+ "Employees",
+ ),
+ },
{
name: "create table foreign key source column list",
sql: "CREATE TABLE NewTable (EmployeeId INT, FOREIGN KEY (|) REFERENCES Employees(Id))",
@@ -491,6 +850,11 @@ func TestCompletionCoverageMatrix(t *testing.T) {
"Street",
),
},
+ {
+ name: "create table named foreign key source column list",
+ sql: "CREATE TABLE NewTable (EmployeeId INT, CONSTRAINT fk FOREIGN KEY (|) REFERENCES Employees(Id))",
+ want: columns("EmployeeId"),
+ },
{
name: "create table references column list",
sql: "CREATE TABLE NewTable (EmployeeId INT REFERENCES Employees(|))",
@@ -501,11 +865,34 @@ func TestCompletionCoverageMatrix(t *testing.T) {
"Street",
),
},
+ {
+ name: "create table schema qualified references column list",
+ sql: "CREATE TABLE NewTable (EmployeeId INT REFERENCES dbo.Employees(|))",
+ want: columns("Id", "Name"),
+ },
+ {
+ name: "create table cross database references column list",
+ sql: "CREATE TABLE NewTable (StudentId INT REFERENCES School.dbo.Student(|))",
+ want: columns("Id", "ParentName"),
+ notWant: columns(
+ "Name",
+ ),
+ },
{
name: "create table type name",
sql: "CREATE TABLE NewTable (Name |)",
want: keywords("INT", "NVARCHAR"),
},
+ {
+ name: "create table type name after comma",
+ sql: "CREATE TABLE NewTable (Id INT, Name |)",
+ want: keywords("INT", "NVARCHAR"),
+ },
+ {
+ name: "declare variable type name",
+ sql: "DECLARE @Name |",
+ want: keywords("INT", "NVARCHAR"),
+ },
{
name: "alter table target reference",
sql: "ALTER TABLE |",
@@ -521,11 +908,34 @@ func TestCompletionCoverageMatrix(t *testing.T) {
sql: "ALTER TABLE School.dbo.|",
want: tables("Student"),
},
+ {
+ name: "alter table add column type name",
+ sql: "ALTER TABLE Employees ADD Name |",
+ want: keywords("INT", "NVARCHAR"),
+ },
+ {
+ name: "alter table references table",
+ sql: "ALTER TABLE Employees ADD CONSTRAINT fk FOREIGN KEY (Id) REFERENCES |",
+ want: tables("Address", "Employees"),
+ },
+ {
+ name: "alter table references column list",
+ sql: "ALTER TABLE Employees ADD CONSTRAINT fk FOREIGN KEY (Id) REFERENCES Address(|)",
+ want: columns("EmployeeId", "Street"),
+ notWant: columns(
+ "Name",
+ ),
+ },
{
name: "drop table reference",
sql: "DROP TABLE |",
want: tables("Address", "Employees"),
},
+ {
+ name: "drop table prefix keeps matching table available",
+ sql: "DROP TABLE Emp|",
+ want: tables("Employees"),
+ },
{
name: "drop table if exists reference",
sql: "DROP TABLE IF EXISTS |",
@@ -541,21 +951,64 @@ func TestCompletionCoverageMatrix(t *testing.T) {
sql: "DROP TABLE School.dbo.|",
want: tables("Student"),
},
+ {
+ name: "drop view schema reference",
+ sql: "DROP VIEW MySchema.|",
+ want: views("SalaryView"),
+ },
+ {
+ name: "drop procedure schema reference",
+ sql: "DROP PROCEDURE dbo.|",
+ want: routines("SyncEmployees"),
+ },
+ {
+ name: "drop procedure prefix keeps matching routine available",
+ sql: "DROP PROCEDURE Sync|",
+ want: routines("SyncEmployees"),
+ },
+ {
+ name: "drop sequence schema reference",
+ sql: "DROP SEQUENCE dbo.|",
+ want: sequences("EmployeeIdSeq", "OrderSeq"),
+ },
+ {
+ name: "drop sequence prefix keeps matching sequence available",
+ sql: "DROP SEQUENCE Employee|",
+ want: sequences("EmployeeIdSeq"),
+ },
{
name: "drop database reference",
sql: "DROP DATABASE |",
want: databases("Company", "School"),
},
+ {
+ name: "drop database prefix keeps matching database available",
+ sql: "DROP DATABASE Comp|",
+ want: databases("Company"),
+ },
{
name: "use database reference",
sql: "USE |",
want: databases("Company", "School"),
},
+ {
+ name: "use database prefix keeps matching database available",
+ sql: "USE Sch|",
+ want: databases("School"),
+ },
{
name: "next value for sequence reference",
sql: "SELECT NEXT VALUE FOR |",
want: sequences("EmployeeIdSeq", "OrderSeq"),
},
+ {
+ name: "next value for sequence prefix",
+ sql: "SELECT NEXT VALUE FOR Employee|",
+ want: sequences("EmployeeIdSeq"),
+ notWant: sequences(
+ "OrderSeq",
+ ),
+ },
{
name: "schema qualified next value for sequence reference",
sql: "SELECT NEXT VALUE FOR dbo.|",
@@ -582,6 +1035,11 @@ func TestCompletionCoverageMatrix(t *testing.T) {
sql: "TRUNCATE TABLE |",
want: tables("Address", "Employees"),
},
+ {
+ name: "truncate cross database table reference",
+ sql: "TRUNCATE TABLE School.dbo.|",
+ want: tables("Student"),
+ },
{
name: "merge target table reference",
sql: "MERGE INTO |",
@@ -597,11 +1055,52 @@ func TestCompletionCoverageMatrix(t *testing.T) {
sql: "MERGE INTO Employees USING Address ON |",
want: columns("Id", "Name", "EmployeeId", "Street"),
},
+ {
+ name: "merge on uses aliased target and source columns",
+ sql: "MERGE INTO Employees AS target USING Address AS source ON source.|",
+ want: columns("EmployeeId", "Street"),
+ notWant: columns(
+ "Name",
+ ),
+ },
+ {
+ name: "merge on uses cte source columns",
+ sql: "WITH source AS (SELECT EmployeeId, Street FROM Address) MERGE INTO Employees AS target USING source ON |",
+ want: columns("Id", "Name", "EmployeeId", "Street"),
+ },
+ {
+ name: "merge on uses subquery source columns",
+ sql: "MERGE INTO Employees AS target USING (SELECT EmployeeId, Street FROM Address) AS source ON source.|",
+ want: columns("EmployeeId", "Street"),
+ notWant: columns(
+ "Name",
+ ),
+ },
{
name: "merge when keyword",
sql: "MERGE INTO Employees USING Address ON Employees.Id = Address.EmployeeId WHEN |",
want: keywords("MATCHED", "NOT"),
},
+ {
+ name: "merge matched update set uses target columns",
+ sql: "MERGE INTO Employees USING Address ON Employees.Id = Address.EmployeeId WHEN MATCHED THEN UPDATE SET |",
+ want: columns("Id", "Name"),
+ },
+ {
+ name: "merge matched update value uses source columns",
+ sql: "MERGE INTO Employees USING Address ON Employees.Id = Address.EmployeeId WHEN MATCHED THEN UPDATE SET Name = Address.|",
+ want: columns("EmployeeId", "Street"),
+ },
+ {
+ name: "merge output inserted columns",
+ sql: "MERGE INTO Employees USING Address ON Employees.Id = Address.EmployeeId WHEN MATCHED THEN UPDATE SET Name = Address.Street OUTPUT INSERTED.|",
+ want: columns("Id", "Name"),
+ },
+ {
+ name: "merge output deleted columns",
+ sql: "MERGE INTO Employees USING Address ON Employees.Id = Address.EmployeeId WHEN MATCHED THEN UPDATE SET Name = Address.Street OUTPUT DELETED.|",
+ want: columns("Id", "Name"),
+ },
{
name: "table hint keyword",
sql: "SELECT * FROM Employees WITH (|)",
@@ -625,7 +1124,7 @@ func TestCompletionCoverageMatrix(t *testing.T) {
{
name: "for xml mode",
sql: "SELECT * FROM Employees FOR XML |",
- want: keywords("PATH", "AUTO"),
+ want: keywords("PATH", "RAW", "AUTO", "EXPLICIT"),
},
{
name: "for json mode",
@@ -637,16 +1136,31 @@ func TestCompletionCoverageMatrix(t *testing.T) {
sql: "SELECT * FROM OPENJSON(@json) WITH (Name |)",
want: keywords("INT", "NVARCHAR"),
},
+ {
+ name: "openjson with second column type name",
+ sql: "SELECT * FROM OPENJSON(@json) WITH (Name NVARCHAR(100), Age |)",
+ want: keywords("INT", "NVARCHAR"),
+ },
{
name: "pivot in list uses source columns",
sql: "SELECT * FROM Employees PIVOT (COUNT(Id) FOR Name IN (|)) p",
want: columns("Id", "Name"),
},
+ {
+ name: "unpivot in list uses source columns",
+ sql: "SELECT * FROM Employees UNPIVOT (Value FOR Field IN (|)) u",
+ want: columns("Id", "Name"),
+ },
{
name: "execute procedure reference",
sql: "EXEC |",
want: routines("SyncEmployees"),
},
+ {
+ name: "execute procedure prefix",
+ sql: "EXEC Sync|",
+ want: routines("SyncEmployees"),
+ },
{
name: "alternate schema execute procedure reference",
sql: "EXEC MySchema.|",
diff --git a/backend/plugin/parser/tsql/query_span_extractor.go b/backend/plugin/parser/tsql/query_span_extractor.go
index ce61eacbc7..d39307a31d 100644
--- a/backend/plugin/parser/tsql/query_span_extractor.go
+++ b/backend/plugin/parser/tsql/query_span_extractor.go
@@ -2,12 +2,10 @@ package tsql
import (
"context"
- "log/slog"
"strings"
"unicode"
"github.com/bytebase/omni/mssql/ast"
- parser "github.com/bytebase/parser/tsql"
"github.com/pkg/errors"
@@ -426,38 +424,6 @@ func isSystemResource(resource base.ColumnResource, ignoreCaseSensitive bool) bo
return false
}
-// normalizeFullTableNameFallback normalizes the parts of an ANTLR full_table_name
-// context. Retained for non-query-span tsql callers (completion, backup).
-func normalizeFullTableNameFallback(fullTableName parser.IFull_table_nameContext, normalizedFallbackDatabaseName, normalizedFallbackSchemaName string) (string, string, string, string) {
- if fullTableName == nil {
- return "", "", "", ""
- }
- // TODO(zp): unify here and the related code in sql_service.go
- name, err := NormalizeFullTableName(fullTableName)
- if err != nil {
- slog.Debug("Failed to normalize full table name", "error", err)
- }
- linkedServer := ""
- if name.LinkedServer != "" {
- linkedServer = name.LinkedServer
- }
-
- database := normalizedFallbackDatabaseName
- if name.Database != "" {
- database = name.Database
- }
- schema := normalizedFallbackSchemaName
- if name.Schema != "" {
- schema = name.Schema
- }
-
- var table string
- if name.Table != "" {
- table = name.Table
- }
- return linkedServer, database, schema, table
-}
-
// unquote strips surrounding brackets or `N'...'` from an identifier literal.
// Retained for non-query-span tsql callers.
func unquote(name string) string {
diff --git a/backend/plugin/parser/tsql/test-data/test_completion.yaml b/backend/plugin/parser/tsql/test-data/test_completion.yaml
index 99120e4712..a37b2b8e91 100644
--- a/backend/plugin/parser/tsql/test-data/test_completion.yaml
+++ b/backend/plugin/parser/tsql/test-data/test_completion.yaml
@@ -46,16 +46,6 @@
- description: Column alias can be used in order by clause
input: SELECT Id AS IdAlias, Name FROM Employees ORDER BY |;
want:
- - text: EmployeeId
- type: COLUMN
- definition: Company.dbo.Address | int, NOT NULL
- comment: ""
- priority: 1
- - text: Id
- type: COLUMN
- definition: Company.MySchema.SalaryLevel | int, NOT NULL
- comment: ""
- priority: 1
- text: Id
type: COLUMN
definition: Company.dbo.Employees | int, NOT NULL
@@ -71,16 +61,6 @@
definition: Company.dbo.Employees | varchar, NOT NULL
comment: ""
priority: 0
- - text: SalaryUpBound
- type: COLUMN
- definition: Company.MySchema.SalaryLevel | int, NOT NULL
- comment: ""
- priority: 1
- - text: Street
- type: COLUMN
- definition: Company.dbo.Address | varchar, NOT NULL
- comment: ""
- priority: 1
- text: Company
type: DATABASE
definition: ""
@@ -150,16 +130,6 @@
- description: Full column name
input: SELECT | FROM Employees;
want:
- - text: EmployeeId
- type: COLUMN
- definition: Company.dbo.Address | int, NOT NULL
- comment: ""
- priority: 1
- - text: Id
- type: COLUMN
- definition: Company.MySchema.SalaryLevel | int, NOT NULL
- comment: ""
- priority: 1
- text: Id
type: COLUMN
definition: Company.dbo.Employees | int, NOT NULL
@@ -170,16 +140,6 @@
definition: Company.dbo.Employees | varchar, NOT NULL
comment: ""
priority: 0
- - text: SalaryUpBound
- type: COLUMN
- definition: Company.MySchema.SalaryLevel | int, NOT NULL
- comment: ""
- priority: 1
- - text: Street
- type: COLUMN
- definition: Company.dbo.Address | varchar, NOT NULL
- comment: ""
- priority: 1
- text: Company
type: DATABASE
definition: ""
@@ -230,24 +190,14 @@
priority: 0
- text: Id
type: COLUMN
- definition: Company.MySchema.SalaryLevel | int, NOT NULL
- comment: ""
- priority: 1
- - text: Id
- type: COLUMN
- definition: Company.dbo.Employees | int, NOT NULL
+ definition: ""
comment: ""
priority: 0
- text: Name
type: COLUMN
- definition: Company.dbo.Employees | varchar, NOT NULL
+ definition: ""
comment: ""
priority: 0
- - text: SalaryUpBound
- type: COLUMN
- definition: Company.MySchema.SalaryLevel | int, NOT NULL
- comment: ""
- priority: 1
- text: Street
type: COLUMN
definition: Company.dbo.Address | varchar, NOT NULL
diff --git a/go.mod b/go.mod
index 80333867b6..70a3871da9 100644
--- a/go.mod
+++ b/go.mod
@@ -34,7 +34,7 @@ require (
github.com/bmatcuk/doublestar/v4 v4.10.0
github.com/bytebase/gomongo v0.0.0-20260403033636-f6c50d4ab888
github.com/bytebase/lsp-protocol v0.0.0-20250324071136-1586d0c10ff0
- github.com/bytebase/omni v0.0.0-20260429081533-45e43fdcdd31
+ github.com/bytebase/omni v0.0.0-20260430035605-5f442197a248
github.com/caarlos0/env/v11 v11.4.0
github.com/cenkalti/backoff/v5 v5.0.3
github.com/cockroachdb/cockroachdb-parser v0.25.2
diff --git a/go.sum b/go.sum
index 3f931c3245..36b067fae2 100644
--- a/go.sum
+++ b/go.sum
@@ -252,8 +252,8 @@ github.com/bytebase/gomongo v0.0.0-20260403033636-f6c50d4ab888 h1:E8tz8maxpih/vt
github.com/bytebase/gomongo v0.0.0-20260403033636-f6c50d4ab888/go.mod h1:IgLUOjyiHehdE0G3C92IjGYu9lJQgkPwf2mdNSvPWq8=
github.com/bytebase/lsp-protocol v0.0.0-20250324071136-1586d0c10ff0 h1:bJ8NSf2K+pccl5m/wuu97fiYjDwpJH6IzURAq/3XA2U=
github.com/bytebase/lsp-protocol v0.0.0-20250324071136-1586d0c10ff0/go.mod h1:BEWMfiZtqshdmulKJcIsWb45MUaEvDO4CROcgi8dfFg=
-github.com/bytebase/omni v0.0.0-20260429081533-45e43fdcdd31 h1:K5u/0cIhf/aGngRKPe2byis3X9g8ZVUQWfaiPubzk68=
-github.com/bytebase/omni v0.0.0-20260429081533-45e43fdcdd31/go.mod h1:EVG8nQbNPUnUBGKn6J0niSGOs3jgfKo3TciY22R4bfo=
+github.com/bytebase/omni v0.0.0-20260430035605-5f442197a248 h1:qrCbq05Wcm2qcKa+f+8MEyXeCRo33HVEVZn8DtH2rmU=
+github.com/bytebase/omni v0.0.0-20260430035605-5f442197a248/go.mod h1:EVG8nQbNPUnUBGKn6J0niSGOs3jgfKo3TciY22R4bfo=
github.com/bytebase/parser v0.0.0-20260417075056-57b6ef7a2640 h1:g4Jed1/Jv/DHBiQmEgN5ILOQDDBjFlG4N4Lp+3B4aYE=
github.com/bytebase/parser v0.0.0-20260417075056-57b6ef7a2640/go.mod h1:jeak/EfutSOAuWKvrFIT2IZunhWprM7oTFBRgZ9RCxo=
github.com/bytebase/pgx/v5 v5.0.0-20250212161523-96ff8aed8767 h1:YuR5G3LcxpO5ScSTA+Kdirxg9RW4TRc/v1t7N2Hfmbw=