Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
feat(partiql): 3/4 replace ANTLR completion engine with omni (#19967)
h3n4le653ac8fbbe4
diff --git a/backend/plugin/parser/partiql/completion.go b/backend/plugin/parser/partiql/completion.goindex d0b033def7..2a9dc6fa5e 100644--- a/backend/plugin/parser/partiql/completion.go+++ b/backend/plugin/parser/partiql/completion.go@@ -4,84 +4,88 @@ import ("context""slices""strings"+ "unicode/utf8"- "github.com/antlr4-go/antlr/v4"- partiqlparser "github.com/bytebase/parser/partiql"+ omnipartiql "github.com/bytebase/omni/partiql"+ "github.com/bytebase/omni/partiql/catalog"+ "github.com/bytebase/omni/partiql/completion"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/parser/base"+ "github.com/bytebase/bytebase/backend/store/model")-var (- // globalFollowSetsByState is the global follow sets by state.- // It is shared by all PostgreSQL completers.- // The FollowSetsByState is the thread-safe struct.- globalFollowSetsByState = base.NewFollowSetsByState()-- ignoredTokens = map[int]bool{- partiqlparser.PartiQLParserParserEOF: true,-- // Operator and literals.- partiqlparser.PartiQLParserParserCARET: true,- partiqlparser.PartiQLParserParserCOMMA: true,- partiqlparser.PartiQLParserParserPLUS: true,- partiqlparser.PartiQLParserParserMINUS: true,- partiqlparser.PartiQLParserParserSLASH_FORWARD: true,- partiqlparser.PartiQLParserParserPERCENT: true,- partiqlparser.PartiQLParserParserAT_SIGN: true,- partiqlparser.PartiQLParserParserTILDE: true,- partiqlparser.PartiQLParserParserASTERISK: true,- partiqlparser.PartiQLParserParserLT_EQ: true,- partiqlparser.PartiQLParserParserGT_EQ: true,- partiqlparser.PartiQLParserParserEQ: true,- partiqlparser.PartiQLParserParserNEQ: true,- partiqlparser.PartiQLParserParserCONCAT: true,- partiqlparser.PartiQLParserParserANGLE_LEFT: true,- partiqlparser.PartiQLParserParserANGLE_RIGHT: true,- partiqlparser.PartiQLParserParserANGLE_DOUBLE_LEFT: true,- partiqlparser.PartiQLParserParserANGLE_DOUBLE_RIGHT: true,- partiqlparser.PartiQLParserParserBRACKET_LEFT: true,- partiqlparser.PartiQLParserParserBRACKET_RIGHT: true,- partiqlparser.PartiQLParserParserBRACE_LEFT: true,- partiqlparser.PartiQLParserParserBRACE_RIGHT: true,- partiqlparser.PartiQLParserParserPAREN_LEFT: true,- partiqlparser.PartiQLParserParserPAREN_RIGHT: true,- partiqlparser.PartiQLParserParserBACKTICK: true,- partiqlparser.PartiQLParserParserCOLON: true,- partiqlparser.PartiQLParserParserCOLON_SEMI: true,- partiqlparser.PartiQLParserParserQUESTION_MARK: true,- partiqlparser.PartiQLParserParserPERIOD: true,-- // Literals & Identifiers.- partiqlparser.PartiQLParserParserLITERAL_STRING: true,- partiqlparser.PartiQLParserParserLITERAL_INTEGER: true,- partiqlparser.PartiQLParserParserLITERAL_DECIMAL: true,- partiqlparser.PartiQLParserParserIDENTIFIER: true,- partiqlparser.PartiQLParserParserIDENTIFIER_QUOTED: true,-- // To Ignore.- partiqlparser.PartiQLParserParserUNRECOGNIZED: true,+func init() {+ base.RegisterCompleteFunc(storepb.Engine_DYNAMODB, Completion)+}++// Completion provides auto-complete candidates for PartiQL statements.+// It uses the omni completion engine for keyword and table suggestions,+// and supplements with column suggestions from bytebase metadata.+func Completion(ctx context.Context, cCtx base.CompletionContext, statement string, caretLine int, caretOffset int) ([]base.Candidate, error) {+ // Build omni catalog from bytebase metadata.+ cat := catalog.New()+ var databaseMetadata *model.DatabaseMetadata+ if cCtx.Metadata != nil && cCtx.DefaultDatabase != "" {+ _, dbMeta, err := cCtx.Metadata(ctx, cCtx.InstanceID, cCtx.DefaultDatabase)+ if err == nil && dbMeta != nil {+ databaseMetadata = dbMeta+ schema := dbMeta.GetSchemaMetadata("")+ if schema != nil {+ for _, table := range schema.ListTableNames() {+ cat.AddTable(table)+ }+ }+ }}- preferredRules = map[int]bool{- // The parser grammar is not friendly to the completion, for the statement "SELECT * FROM Music", the fromClause parse- // tree is:- // fromClause -> tableReference -> TableNonJoin -> ...(12) -> varRefExpr -> IDENTIFIER- // So we set the varRefExpr as the preferred rule to get the table name, although it's not the most accurate rule.- partiqlparser.PartiQLParserParserRULE_varRefExpr: true,+ // Convert (line, offset) to byte position in the statement.+ pos := lineOffsetToBytePos(statement, caretLine, caretOffset)++ // Get omni completion candidates.+ omniCandidates := completion.Complete(statement, pos, cat)++ // Convert to base.Candidate format.+ candidateMap := make(map[string]base.Candidate)+ for _, c := range omniCandidates {+ var candidateType base.CandidateType+ switch c.Kind {+ case "keyword":+ candidateType = base.CandidateTypeKeyword+ case "table":+ candidateType = base.CandidateTypeTable+ default:+ candidateType = base.CandidateTypeNone+ }+ key := candidateKey(c.Text, candidateType)+ candidateMap[key] = base.Candidate{+ Type: candidateType,+ Text: c.Text,+ }}-)-type CompletionMap map[string]base.Candidate+ // Add column completions if we detect a SELECT-item context.+ // The omni completion engine handles keyword/table contexts; for columns,+ // we check whether the cursor is in a position where columns are relevant+ // (after SELECT but before FROM, or in WHERE/HAVING clauses).+ if databaseMetadata != nil && isColumnContext(statement, pos) {+ addColumnCandidates(candidateMap, statement, pos, databaseMetadata)+ }-func (m CompletionMap) Insert(entry base.Candidate) {- m[entry.String()] = entry-}+ // Filter candidates by scene. In query-only mode, exclude DML/DDL+ // keywords that are not valid in read-only editor contexts.+ if cCtx.Scene == base.SceneTypeQuery {+ for key, c := range candidateMap {+ if c.Type == base.CandidateTypeKeyword && isDMLKeyword(c.Text) {+ delete(candidateMap, key)+ }+ }+ }-func (m CompletionMap) toSlice() []base.Candidate {+ // Sort and return.var result []base.Candidate- for _, candidate := range m {- result = append(result, candidate)+ for _, c := range candidateMap {+ result = append(result, c)}slices.SortFunc(result, func(a, b base.Candidate) int {if a.Type != b.Type {@@ -98,501 +102,416 @@ func (m CompletionMap) toSlice() []base.Candidate {}return 0})- return result+ return result, nil}-func (m CompletionMap) insertMetadataColumns(c *Completer) {- for _, reference := range c.references {- if physicalTableReference, ok := reference.(*base.PhysicalTableReference); ok {- database := c.defaultDatabase- if physicalTableReference.Database != "" {- database = physicalTableReference.Database- }- if database == "" {- continue- }- _, databaseMetadata, err := c.metadataGetter(c.ctx, c.instanceID, c.defaultDatabase)- if err != nil {- return- }- if databaseMetadata == nil {- return- }- schema := databaseMetadata.GetSchemaMetadata("")- if schema == nil {- return- }- var tableName string- for _, table := range schema.ListTableNames() {- if strings.EqualFold(table, physicalTableReference.Table) {- tableName = table- break- }- }- if tableName == "" {- return- }- table := schema.GetTable(tableName)- if table == nil {- return- }- for _, column := range table.GetProto().GetColumns() {- if _, ok := m[column.Name]; !ok {- m.Insert(base.Candidate{- Type: base.CandidateTypeColumn,- Text: column.Name,- })- }- }+// lineOffsetToBytePos converts a 1-based line number and 0-based+// character (rune) offset to a 0-based byte position in the string.+// The offset is in characters, not bytes, so we iterate runes to+// handle multibyte UTF-8 correctly.+func lineOffsetToBytePos(s string, line, offset int) int {+ pos := 0+ currentLine := 1+ for pos < len(s) && currentLine < line {+ if s[pos] == '\n' {+ currentLine++}+ pos++}-}--func (m CompletionMap) insertMetadataTables(c *Completer) {- if c.defaultDatabase == "" {- return- }- _, databaseMetadata, err := c.metadataGetter(c.ctx, c.instanceID, c.defaultDatabase)- if err != nil {- return- }- if databaseMetadata == nil {- return+ // Now advance by `offset` runes (not bytes) within the target line.+ for i := 0; i < offset && pos < len(s); i++ {+ _, size := utf8.DecodeRuneInString(s[pos:])+ pos += size}- schema := databaseMetadata.GetSchemaMetadata("")- if schema == nil {- return+ if pos > len(s) {+ return len(s)}- for _, table := range schema.ListTableNames() {- if _, ok := m[table]; !ok {- m.Insert(base.Candidate{- Type: base.CandidateTypeTable,- Text: table,- })- }- }-}--func init() {- base.RegisterCompleteFunc(storepb.Engine_DYNAMODB, Completion)+ return pos}-type Completer struct {- ctx context.Context- core *base.CodeCompletionCore- scene base.SceneType- parser *partiqlparser.PartiQLParserParser- lexer *partiqlparser.PartiQLLexer- scanner *base.Scanner-- instanceID string- defaultDatabase string- defaultSchema string- metadataGetter base.GetDatabaseMetadataFunc-- noSeparatorRequired map[int]bool- // 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+// candidateKey produces a dedup key for a candidate.+func candidateKey(text string, typ base.CandidateType) string {+ return string(typ) + ":" + text}-func Completion(ctx context.Context, cCtx base.CompletionContext, statement string, caretLine int, caretOffset int) ([]base.Candidate, error) {- completer := NewStandardCompleter(ctx, cCtx, statement, caretLine, caretOffset)- result, err := completer.complete()- if err != nil {- return nil, err+// isColumnContext returns true if the cursor position appears to be in a+// context where column names should be suggested. This covers:+// - Between SELECT and FROM (the projection list)+// - After FROM when inside a clause that takes expressions: WHERE,+// HAVING, SET, ORDER BY, GROUP BY, and any operator/function position+// within those clauses (e.g., WHERE Artist = |)+//+// Table-only contexts (immediately after FROM/JOIN/INTO) return false.+func isColumnContext(statement string, pos int) bool {+ if pos > len(statement) {+ pos = len(statement)}- if len(result) > 0 {- return result, nil+ // Strip quoted identifiers before uppercasing so that "order" doesn't+ // match the ORDER keyword in lastKeywordIndex.+ before := strings.ToUpper(stripQuotedIdentifiers(statement[:pos]))++ // Strip any partial identifier the user is currently typing.+ trimmed := strings.TrimRight(before, "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_$\"")+ trimmed = strings.TrimRight(trimmed, " \t\n\r")++ // Table context: cursor is right after FROM/JOIN/INTO.+ if strings.HasSuffix(trimmed, "FROM") ||+ strings.HasSuffix(trimmed, "JOIN") ||+ strings.HasSuffix(trimmed, "INTO") {+ return false}- trickyCompleter := NewTrickyCompleter(ctx, cCtx, statement, caretLine, caretOffset)- return trickyCompleter.complete()-}+ // Between SELECT and FROM (the projection list) — column context.+ selectIdx := lastKeywordIndex(before, "SELECT")+ fromIdx := lastKeywordIndex(before, "FROM")+ if selectIdx >= 0 && (fromIdx < 0 || fromIdx < selectIdx) {+ return true+ }-func NewTrickyCompleter(ctx context.Context, cCtx base.CompletionContext, statement string, caretLine int, caretOffset int) *Completer {- parser, lexer, scanner := prepareTrickyParserAndScanner(statement, caretLine, caretOffset)- core := base.NewCodeCompletionCore(- ctx,- parser,- ignoredTokens, /* IgnoredTokens */- preferredRules, /* PreferredRules */- &globalFollowSetsByState,- partiqlparser.PartiQLParserParserRULE_exprSelect, /* queryRule */- -1, /* shadowQueryRule */- -1, /* selectItemAliasRule */- -1, /* cteRule */- )-- return &Completer{- ctx: ctx,- core: core,- scene: cCtx.Scene,- parser: parser,- lexer: lexer,- scanner: scanner,- instanceID: cCtx.InstanceID,- defaultDatabase: cCtx.DefaultDatabase,- defaultSchema: "dbo",- metadataGetter: cCtx.Metadata,- noSeparatorRequired: make(map[int]bool),+ // After FROM: if any expression-bearing clause keyword appears in the+ // text before the cursor, we're in a column context.+ for _, kw := range []string{"WHERE", "HAVING", "SET", "ORDER", "GROUP", "BY", "AND", "OR", "ON", "WHEN", "THEN", "ELSE"} {+ kwIdx := lastKeywordIndex(before, kw)+ if kwIdx >= 0 && kwIdx > fromIdx {+ return true+ }}-}-func NewStandardCompleter(ctx context.Context, cCtx base.CompletionContext, statement string, caretLine int, caretOffset int) *Completer {- parser, lexer, scanner := prepareParserAndScanner(statement, caretLine, caretOffset)- core := base.NewCodeCompletionCore(- ctx,- parser,- ignoredTokens, /* IgnoredTokens */- preferredRules, /* PreferredRules */- &globalFollowSetsByState,- partiqlparser.PartiQLParserParserRULE_exprSelect, /* queryRule */- -1, /* shadowQueryRule */- -1, /* selectItemAliasRule */- -1, /* cteRule */- )-- return &Completer{- ctx: ctx,- core: core,- scene: cCtx.Scene,- parser: parser,- lexer: lexer,- scanner: scanner,- instanceID: cCtx.InstanceID,- defaultDatabase: cCtx.DefaultDatabase,- defaultSchema: "dbo",- metadataGetter: cCtx.Metadata,- noSeparatorRequired: nil,+ // Fallback: if FROM was seen and the cursor is past it in a position+ // that is NOT right after FROM/JOIN/INTO (already excluded above),+ // we're likely in an expression context within a clause.+ if fromIdx >= 0 {+ for _, kw := range []string{"WHERE", "HAVING", "SET", "ORDER", "GROUP"} {+ if lastKeywordIndex(before, kw) > fromIdx {+ return true+ }+ }}++ return false}-func (c *Completer) complete() ([]base.Candidate, error) {- caretIndex := c.scanner.GetIndex()- if caretIndex > 0 && !c.noSeparatorRequired[c.scanner.GetPreviousTokenType(true)] {- caretIndex--- }- c.referencesStack = append([][]base.TableReference{{}}, c.referencesStack...)- c.parser.Reset()- var context antlr.ParserRuleContext- if c.scene == base.SceneTypeQuery {- context = c.parser.SelectClause()- } else {- context = c.parser.Script()- }- candidates := c.core.CollectCandidates(caretIndex, context)-- for ruleName := range candidates.Rules {- if ruleName == partiqlparser.PartiQLParserParserRULE_varRefExpr {- c.collectLeadingTableReferences(caretIndex)- c.takeReferencesSnapshot()- c.collectRemainingTableReferences()- c.takeReferencesSnapshot()+// lastKeywordIndex returns the index of the last occurrence of kw in s+// that appears at a word boundary (not inside an identifier). Returns -1+// if not found. Both s and kw must be uppercase.+func lastKeywordIndex(s, kw string) int {+ search := s+ for {+ idx := strings.LastIndex(search, kw)+ if idx < 0 {+ return -1+ }+ end := idx + len(kw)+ startOk := idx == 0 || !isIdentRune(rune(search[idx-1]))+ endOk := end >= len(search) || !isIdentRune(rune(search[end]))+ if startOk && endOk {+ return idx}+ // Shrink the search window and try again.+ search = search[:idx]}+}- return c.convertCandidates(candidates)+func isIdentRune(r rune) bool {+ return (r >= 'A' && r <= 'Z') || (r >= 'a' && r <= 'z') ||+ (r >= '0' && r <= '9') || r == '_' || r == '$'}-func (c *Completer) takeReferencesSnapshot() {- for _, references := range c.referencesStack {- c.references = append(c.references, references...)+// addColumnCandidates extracts column names from tables referenced in+// the active statement (the one containing the cursor) and adds them+// to the candidate map. It isolates the current statement by finding+// the semicolon boundaries around pos, then scans the FULL current+// statement (including text after the cursor, e.g., FROM clauses that+// follow a SELECT |).+func addColumnCandidates(m map[string]base.Candidate, statement string, pos int, dbMeta *model.DatabaseMetadata) {+ schema := dbMeta.GetSchemaMetadata("")+ if schema == nil {+ return}-}-func (c *Completer) convertCandidates(candidates *base.CandidatesCollection) ([]base.Candidate, error) {- keywordEntries := make(CompletionMap)- tableEntries := make(CompletionMap)- columnEntries := make(CompletionMap)- for tokenCandidate, continuous := range candidates.Tokens {- if tokenCandidate < 0 || tokenCandidate >= len(c.parser.SymbolicNames) {+ // Isolate the current statement: find the semicolons before and after pos.+ currentStmt := extractCurrentStatement(statement, pos)+ tables := extractTableNamesFromStatement(currentStmt)+ if len(tables) == 0 {+ // If no FROM clause found, try all tables.+ tables = schema.ListTableNames()+ }++ for _, tableName := range tables {+ // Case-sensitive lookup to match DynamoDB behavior.+ var actualName string+ for _, t := range schema.ListTableNames() {+ if strings.EqualFold(t, tableName) {+ actualName = t+ break+ }+ }+ if actualName == "" {+ continue+ }+ table := schema.GetTable(actualName)+ if table == nil {continue}- candidateText := c.parser.SymbolicNames[tokenCandidate]- for _, continuous := range continuous {- if continuous < 0 || continuous >= len(c.parser.SymbolicNames) {- continue+ for _, col := range table.GetProto().GetColumns() {+ key := candidateKey(col.Name, base.CandidateTypeColumn)+ if _, exists := m[key]; !exists {+ m[key] = base.Candidate{+ Type: base.CandidateTypeColumn,+ Text: col.Name,+ }}- continuousText := c.parser.SymbolicNames[continuous]- candidateText += " " + continuousText}- keywordEntries.Insert(base.Candidate{- Type: base.CandidateTypeKeyword,- Text: candidateText,- })}+}- for ruleCandidate, ruleStack := range candidates.Rules {- c.scanner.PopAndRestore()- c.scanner.Push()-- switch ruleCandidate {- case partiqlparser.PartiQLParserParserRULE_varRefExpr:- isSelectItem := false- isFromClause := false- // If previous token contains from, we insert the table names, otherwise we insert the column names.- for _, rule := range ruleStack {- if rule.ID == partiqlparser.PartiQLParserParserRULE_selectClause {- isSelectItem = true- break- } else if rule.ID == partiqlparser.PartiQLParserParserRULE_fromClause {- isFromClause = true+// extractTableNamesFromStatement scans the statement to find table names+// after FROM/JOIN/INTO keywords. Handles:+// - Comma-separated tables with or without spaces: FROM Music, Album / FROM Music,Album+// - Quoted identifiers that match keywords: FROM "order" → table "order" (not keyword ORDER)+// - Aliases: FROM Music AS m, Album a → extracts Music and Album+// - Comments between keywords and table names (stripped before scanning)+func extractTableNamesFromStatement(statement string) []string {+ // Strip comments, then split on whitespace AND commas to handle+ // both "Music, Album" and "Music,Album" uniformly.+ cleaned := stripSQLComments(statement)+ tokens := tokenizeForTableExtraction(cleaned)++ var tables []string+ i := 0+ for i < len(tokens) {+ upper := strings.ToUpper(tokens[i].text)+ if (upper == "FROM" || upper == "JOIN" || upper == "INTO") && i+1 < len(tokens) {+ i+++ // Collect table names from a comma-separated list.+ for i < len(tokens) {+ tok := tokens[i]+ // A quoted identifier is always a table name, even if+ // its unquoted form matches a keyword.+ name := tok.text+ if tok.quoted {+ tables = append(tables, name)+ } else if isKeyword(strings.ToUpper(name)) {break+ } else {+ tables = append(tables, name)}+ i+++ // Skip optional AS + alias.+ if i < len(tokens) && strings.ToUpper(tokens[i].text) == "AS" {+ i += 2 // skip AS and alias+ } else if i < len(tokens) && !tokens[i].comma && !isKeyword(strings.ToUpper(tokens[i].text)) {+ // Implicit alias — skip one token.+ i+++ }+ // If the next token is a comma separator, continue.+ if i < len(tokens) && tokens[i].comma {+ i++ // skip the comma marker+ continue+ }+ break}-- if isSelectItem {- columnEntries.insertMetadataColumns(c)- }- if isFromClause {- tableEntries.insertMetadataTables(c)- }- default:+ } else {+ i++}}-- c.scanner.PopAndRestore()- var result []base.Candidate- result = append(result, keywordEntries.toSlice()...)- result = append(result, tableEntries.toSlice()...)- result = append(result, columnEntries.toSlice()...)- return result, nil+ return tables}-func (c *Completer) collectLeadingTableReferences(caretIndex int) {- c.scanner.Push()-- c.scanner.SeekIndex(0)-- level := 0- for {- found := c.scanner.GetTokenType() == partiqlparser.PartiQLLexerFROM- for !found {- if !c.scanner.Forward(false) || c.scanner.GetIndex() >= caretIndex {- break- }+// tableToken is a token in the table-extraction scanner.+type tableToken struct {+ text string // the identifier or keyword text (quotes stripped)+ quoted bool // true if the original was double-quoted+ comma bool // true if this is a comma separator+}- switch c.scanner.GetTokenType() {- case partiqlparser.PartiQLLexerPAREN_LEFT:- level++- c.referencesStack = append([][]base.TableReference{{}}, c.referencesStack...)- case partiqlparser.PartiQLLexerPAREN_RIGHT:- if level == 0 {- c.scanner.PopAndRestore()- return // We cannot go above the initial nesting level.+// tokenizeForTableExtraction splits a comment-stripped SQL string into+// tokens suitable for table-name extraction. It splits on whitespace+// and commas, handling:+// - "Music,Album" → [Music] [,] [Album]+// - "Music , Album" → [Music] [,] [Album]+// - `"order"` → [{text:"order", quoted:true}]+func tokenizeForTableExtraction(s string) []tableToken {+ var tokens []tableToken+ i := 0+ for i < len(s) {+ // Skip whitespace.+ if s[i] == ' ' || s[i] == '\t' || s[i] == '\n' || s[i] == '\r' {+ i+++ continue+ }+ // Comma is its own token.+ if s[i] == ',' {+ tokens = append(tokens, tableToken{comma: true})+ i+++ continue+ }+ // Double-quoted identifier.+ if s[i] == '"' {+ i++ // skip opening "+ start := i+ for i < len(s) && s[i] != '"' {+ if s[i] == '"' && i+1 < len(s) && s[i+1] == '"' {+ i += 2+ continue}- case partiqlparser.PartiQLLexerFROM:- found = true- default:- // Continue scanning for FROM clause+ i+++ }+ text := s[start:i]+ if i < len(s) {+ i++ // skip closing "}+ tokens = append(tokens, tableToken{text: text, quoted: true})+ continue}- if !found {- c.scanner.PopAndRestore()- return // No FROM clause found.+ // Bare word: identifier or keyword.+ start := i+ for i < len(s) && s[i] != ' ' && s[i] != '\t' && s[i] != '\n' &&+ s[i] != '\r' && s[i] != ',' && s[i] != '"' && s[i] != ';' &&+ s[i] != '(' && s[i] != ')' {+ i++}- c.parseTableReferences(c.scanner.GetFollowingText())- if c.scanner.GetTokenType() == partiqlparser.PartiQLLexerFROM {- c.scanner.Forward(false /* skipHidden */)+ if i > start {+ tokens = append(tokens, tableToken{text: s[start:i]})+ } else {+ // Delimiter character like (, ), ; — skip it to avoid+ // an infinite loop.+ i++}}+ return tokens}-func (c *Completer) collectRemainingTableReferences() {- c.scanner.Push()-- level := 0- for {- found := c.scanner.GetTokenType() == partiqlparser.PartiQLLexerFROM- for !found {- if !c.scanner.Forward(false /* skipHidden */) {- break- }-- switch c.scanner.GetTokenType() {- case partiqlparser.PartiQLLexerPAREN_LEFT:- level++- c.referencesStack = append([][]base.TableReference{{}}, c.referencesStack...)- case partiqlparser.PartiQLLexerPAREN_RIGHT:- if level > 0 {- level--+// stripSQLComments removes line comments (--...) and block comments+// (/*...*/) from a SQL string, replacing them with spaces to preserve+// token boundaries. Respects single-quoted strings.+func stripSQLComments(s string) string {+ var b strings.Builder+ b.Grow(len(s))+ i := 0+ for i < len(s) {+ switch {+ case s[i] == '\'':+ // Single-quoted string: copy verbatim.+ b.WriteByte(s[i])+ i+++ for i < len(s) {+ b.WriteByte(s[i])+ if s[i] == '\'' {+ i+++ if i < len(s) && s[i] == '\'' {+ b.WriteByte(s[i])+ i+++ continue+ }+ break}-- case partiqlparser.PartiQLLexerFROM:- if level == 0 {- found = true+ i+++ }+ case s[i] == '-' && i+1 < len(s) && s[i+1] == '-':+ // Line comment: replace with space.+ b.WriteByte(' ')+ i += 2+ for i < len(s) && s[i] != '\n' && s[i] != '\r' {+ i+++ }+ case s[i] == '/' && i+1 < len(s) && s[i+1] == '*':+ // Block comment: replace with space.+ b.WriteByte(' ')+ i += 2+ depth := 1+ for i+1 < len(s) && depth > 0 {+ if s[i] == '/' && s[i+1] == '*' {+ depth+++ i += 2+ } else if s[i] == '*' && s[i+1] == '/' {+ depth--+ i += 2+ } else {+ i++}- default:- // Continue scanning}- }-- if !found {- c.scanner.PopAndRestore()- return // No more FROM clause found.- }-- c.parseTableReferences(c.scanner.GetFollowingText())- if c.scanner.GetTokenType() == partiqlparser.PartiQLLexerFROM {- c.scanner.Forward(false /* skipHidden */)+ default:+ b.WriteByte(s[i])+ i++}}+ return b.String()}-func (c *Completer) parseTableReferences(fromClause string) {- input := antlr.NewInputStream(fromClause)- lexer := partiqlparser.NewPartiQLLexer(input)- tokens := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)- parser := partiqlparser.NewPartiQLParserParser(tokens)-- parser.BuildParseTrees = true- parser.RemoveErrorListeners()- tree := parser.FromClause()- listener := &tableRefListener{- context: c,- fromClauseMode: true,+// extractCurrentStatement returns the statement segment containing pos+// by using omni's Split to find the correct semicolon boundaries. This+// respects strings, comments, and Ion literals — a semicolon inside+// 'a;b' won't split the statement.+func extractCurrentStatement(statement string, pos int) string {+ segs := omnipartiql.Split(statement)+ for _, seg := range segs {+ if pos >= seg.ByteStart && pos <= seg.ByteEnd {+ return seg.Text+ }}- antlr.ParseTreeWalkerDefault.Walk(listener, tree)+ // Fallback: return the whole statement.+ return statement}-type tableRefListener struct {- *partiqlparser.BasePartiQLParserListener-- context *Completer- fromClauseMode bool-}--func (l *tableRefListener) EnterVarRefExpr(ctx *partiqlparser.VarRefExprContext) {- name := unquote(ctx.GetText())- l.context.references = append(l.context.references, &base.PhysicalTableReference{- Table: name,- })-}--func unquote(s string) string {- if len(s) < 2 {- return s- }- if s[0] == '"' && s[len(s)-1] == '"' {- return s[1 : len(s)-1]+// isKeyword returns true if the given uppercase word is a SQL keyword.+func isKeyword(w string) bool {+ switch w {+ case "SELECT", "FROM", "WHERE", "AND", "OR", "NOT", "INSERT", "INTO",+ "VALUE", "VALUES", "UPDATE", "SET", "DELETE", "CREATE", "DROP",+ "TABLE", "INDEX", "AS", "AT", "BY", "ON", "IN", "IS", "LIKE",+ "BETWEEN", "ORDER", "GROUP", "HAVING", "LIMIT", "OFFSET",+ "JOIN", "LEFT", "RIGHT", "INNER", "OUTER", "CROSS",+ "UNION", "INTERSECT", "EXCEPT", "DISTINCT", "ALL",+ "NULL", "MISSING", "TRUE", "FALSE", "CAST", "CASE", "WHEN",+ "THEN", "ELSE", "END", "EXISTS", "ASC", "DESC", "EXPLAIN":+ return true}- return s+ return false}-func prepareTrickyParserAndScanner(statement string, caretLine int, caretOffset int) (*partiqlparser.PartiQLParserParser, *partiqlparser.PartiQLLexer, *base.Scanner) {- statement, caretLine, caretOffset = skipHeadingSQLs(statement, caretLine, caretOffset)- statement, caretLine, caretOffset = skipHeadingSQLWithoutSemicolon(statement, caretLine, caretOffset)- input := antlr.NewInputStream(statement)- lexer := partiqlparser.NewPartiQLLexer(input)- stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)- parser := partiqlparser.NewPartiQLParserParser(stream)- parser.RemoveErrorListeners()- lexer.RemoveErrorListeners()- scanner := base.NewScanner(stream, true /* fillInput */)- scanner.SeekPosition(caretLine, caretOffset)- scanner.Push()- return parser, lexer, scanner-}--// caretLine is 1-based and caretOffset is 0-based.-func skipHeadingSQLWithoutSemicolon(statement string, caretLine int, caretOffset int) (string, int, int) {- input := antlr.NewInputStream(statement)- lexer := partiqlparser.NewPartiQLLexer(input)- stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)- lexer.RemoveErrorListeners()- lexerErrorListener := &base.ParseErrorListener{- Statement: statement,- }- lexer.AddErrorListener(lexerErrorListener)-- stream.Fill()- tokens := stream.GetAllTokens()- latestSelect := 0- newCaretLine, newCaretOffset := caretLine, caretOffset- for _, token := range tokens {- if token.GetLine() > caretLine || (token.GetLine() == caretLine && token.GetColumn() >= caretOffset) {- break- }- if token.GetTokenType() == partiqlparser.PartiQLLexerSELECT && token.GetColumn() == 0 {- latestSelect = token.GetTokenIndex()- newCaretLine = caretLine - token.GetLine() + 1 // convert to 1-based.- newCaretOffset = caretOffset- }- }- if latestSelect == 0 {- return statement, caretLine, caretOffset+// isDMLKeyword returns true if the keyword is a DML/DDL operation that+// should be excluded in query-only (read-only) editor scenes.+func isDMLKeyword(w string) bool {+ switch strings.ToUpper(w) {+ case "INSERT", "UPDATE", "DELETE", "CREATE", "DROP", "REPLACE",+ "UPSERT", "REMOVE", "SET":+ return true}- return stream.GetTextFromInterval(antlr.NewInterval(latestSelect, stream.Size())), newCaretLine, newCaretOffset+ return false}-func prepareParserAndScanner(statement string, caretLine int, caretOffset int) (*partiqlparser.PartiQLParserParser, *partiqlparser.PartiQLLexer, *base.Scanner) {- statement, caretLine, caretOffset = skipHeadingSQLs(statement, caretLine, caretOffset)- input := antlr.NewInputStream(statement)- lexer := partiqlparser.NewPartiQLLexer(input)- stream := antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)- parser := partiqlparser.NewPartiQLParserParser(stream)- parser.RemoveErrorListeners()- lexer.RemoveErrorListeners()- scanner := base.NewScanner(stream, true /* fillInput */)- scanner.SeekPosition(caretLine, caretOffset)- scanner.Push()- return parser, lexer, scanner-}--// skipHeadingSQLs skips the SQL statements which before the caret position.-// caretLine is 1-based and caretOffset is 0-based.-func skipHeadingSQLs(statement string, caretLine int, caretOffset int) (string, int, int) {- newCaretLine, newCaretOffset := caretLine, caretOffset- list, err := SplitSQL(statement)- if err != nil || notEmptySQLCount(list) <= 1 {- return statement, caretLine, caretOffset- }-- caretLine-- // Convert to 0-based.-- start := 0- for i, sql := range list {- sqlEndLine := int(sql.End.GetLine())- sqlEndColumn := int(sql.End.GetColumn())- if sqlEndLine > caretLine || (sqlEndLine == caretLine && sqlEndColumn >= caretOffset) {- start = i- if i == 0 {- // The caret is in the first SQL statement, so we don't need to skip any SQL statements.- break- }- previousSQLEndLine := int(list[i-1].End.GetLine())- previousSQLEndColumn := int(list[i-1].End.GetColumn())- newCaretLine = caretLine - previousSQLEndLine + 1 // Convert to 1-based.- if caretLine == previousSQLEndLine {- // The caret is in the same line as the last line of the previous SQL statement.- // End.Column is 1-based exclusive, so (End.Column - 1) gives 0-based start of next statement.- // newCaretOffset = caretOffset - (previousSQLEndColumn - 1)- newCaretOffset = caretOffset - previousSQLEndColumn + 1+// stripQuotedIdentifiers replaces double-quoted identifiers with+// placeholder text so that keyword searches don't match content inside+// quotes (e.g., "order" should not be treated as the ORDER keyword).+func stripQuotedIdentifiers(s string) string {+ var b strings.Builder+ b.Grow(len(s))+ i := 0+ for i < len(s) {+ if s[i] == '"' {+ // Replace the entire "..." with underscores to preserve length.+ b.WriteByte('_')+ i++ // skip opening "+ for i < len(s) {+ if s[i] == '"' {+ i+++ if i < len(s) && s[i] == '"' {+ b.WriteByte('_')+ b.WriteByte('_')+ i+++ continue+ }+ b.WriteByte('_')+ break+ }+ b.WriteByte('_')+ i++}- break- }- }-- var buf strings.Builder- for i := start; i < len(list); i++ {- if _, err := buf.WriteString(list[i].Text); err != nil {- return statement, caretLine, caretOffset- }- }-- return buf.String(), newCaretLine, newCaretOffset-}--func notEmptySQLCount(list []base.Statement) int {- count := 0- for _, sql := range list {- if !sql.Empty {- count+++ } else {+ b.WriteByte(s[i])+ i++}}- return count+ return b.String()}