Add support for MSSQL-style bracket quoted identifiers

FEATURE: Allow `[` in `identifierQuotes` for MSSQL-style bracketed identifiers.

Author: m-yst-ery

src/complete.ts

@@ -13,7 +13,7 @@ function tokenBefore(tree: SyntaxNode) {
 
 function idName(doc: Text, node: SyntaxNode): string {
   let text = doc.sliceString(node.from, node.to)
-  let quoted = /^([`'"])(.*)\1$/.exec(text)
+  let quoted = /^([`'"\[])(.*)([`'"\]])$/.exec(text)
   return quoted ? quoted[2] : text
 }
 
@@ -86,12 +86,11 @@ function getAliases(doc: Text, at: SyntaxNode) {
   return aliases
 }
 
-function maybeQuoteCompletions(quote: string | null, completions: readonly Completion[]) {
-  if (!quote) return completions
-  return completions.map(c => ({...c, label: c.label[0] == quote ? c.label : quote + c.label + quote, apply: undefined}))
+function maybeQuoteCompletions(openingQuote: string, closingQuote: string, completions: readonly Completion[]) {
+  return completions.map(c => ({...c, label: c.label[0] == openingQuote ? c.label : openingQuote + c.label + closingQuote, apply: undefined}))
 }
 
-const Span = /^\w*$/, QuotedSpan = /^[`'"]?\w*[`'"]?$/
+const Span = /^\w*$/, QuotedSpan = /^[`'"\[]?\w*[`'"\]]?$/
 
 function isSelfTag(namespace: SQLNamespace): namespace is {self: Completion, children: SQLNamespace} {
   return (namespace as any).self && typeof (namespace as any).self.label == "string"
@@ -156,7 +155,12 @@ class CompletionLevel {
 
 function nameCompletion(label: string, type: string, idQuote: string, idCaseInsensitive: boolean): Completion {
   if ((new RegExp("^[a-z_][a-z_\\d]*$", idCaseInsensitive ? "i" : "")).test(label)) return {label, type}
-  return {label, type, apply: idQuote + label + idQuote}
+
+  return {label, type, apply: idQuote + label + getClosingQuote(idQuote)}
+}
+
+function getClosingQuote(openingQuote: string) {
+  return openingQuote === "[" ? "]" : openingQuote;
 }
 
 // Some of this is more gnarly than it has to be because we're also
@@ -191,15 +195,29 @@ export function completeFromSchema(schema: SQLNamespace,
       if (!next) return null
       level = next
     }
-    let quoteAfter = quoted && context.state.sliceDoc(context.pos, context.pos + 1) == quoted
+
     let options = level.list
     if (level == top && aliases)
       options = options.concat(Object.keys(aliases).map(name => ({label: name, type: "constant"})))
-    return {
-      from,
-      to: quoteAfter ? context.pos + 1 : undefined,
-      options: maybeQuoteCompletions(quoted, options),
-      validFor: quoted ? QuotedSpan : Span
+
+    if (quoted) {
+      let openingQuote = quoted[0]
+      let closingQuote = getClosingQuote(openingQuote);
+
+      let quoteAfter = context.state.sliceDoc(context.pos, context.pos + 1) == closingQuote
+
+      return {
+        from,
+        to: quoteAfter ? context.pos + 1 : undefined,
+        options: maybeQuoteCompletions(openingQuote, closingQuote, options),
+        validFor: QuotedSpan,
+      }
+    } else {
+      return {
+        from,
+        options: options,
+        validFor: Span
+      }
     }
   }
 }

src/sql.ts

@@ -75,7 +75,7 @@ export type SQLDialectSpec = {
   /// Defaults to `"?"`.
   specialVar?: string,
   /// The characters that can be used to quote identifiers. Defaults
-  /// to `"\""`.
+  /// to `"\""`. Add `[` for MSSQL-style bracket quoted identifiers.
   identifierQuotes?: string
   /// Controls whether identifiers are case-insensitive. Identifiers
   /// with upper-case letters are quoted when set to false (which is
@@ -318,7 +318,8 @@ export const MSSQL = SQLDialect.define({
   types: SQLTypes + "smalldatetime datetimeoffset datetime2 datetime bigint smallint smallmoney tinyint money real text nvarchar ntext varbinary image hierarchyid uniqueidentifier sql_variant xml",
   builtin: MSSQLBuiltin,
   operatorChars: "*+-%<>!=^&|/",
-  specialVar: "@"
+  specialVar: "@",
+  identifierQuotes: "\"["
 })
 
 /// [SQLite](https://sqlite.org/) dialect.

src/tokens.ts

@@ -269,6 +269,10 @@ export function tokensFor(d: Dialect) {
       input.advance(2)
       readPLSQLQuotedLiteral(input, openDelim)
       input.acceptToken(StringToken)
+    } else if (inString(next, d.identifierQuotes)) {
+      const endQuote = next == Ch.BracketL ? Ch.BracketR : next
+      readLiteral(input, endQuote, false)
+      input.acceptToken(QuotedIdentifier)
     } else if (next == Ch.ParenL) {
       input.acceptToken(ParenL)
     } else if (next == Ch.ParenR) {
@@ -319,9 +323,6 @@ export function tokensFor(d: Dialect) {
       if (input.next == next) input.advance()
       readWordOrQuoted(input)
       input.acceptToken(SpecialVar)
-    } else if (inString(next, d.identifierQuotes)) {
-      readLiteral(input, next, false)
-      input.acceptToken(QuotedIdentifier)
     } else if (next == Ch.Colon || next == Ch.Comma) {
       input.acceptToken(Punctuation)
     } else if (isAlpha(next)) {

test/test-complete.ts

@@ -1,6 +1,6 @@
 import {EditorState} from "@codemirror/state"
 import {CompletionContext, CompletionResult, CompletionSource} from "@codemirror/autocomplete"
-import {schemaCompletionSource, keywordCompletionSource, PostgreSQL, MySQL, SQLConfig, SQLDialect} from "@codemirror/lang-sql"
+import {schemaCompletionSource, keywordCompletionSource, PostgreSQL, MySQL, SQLConfig, SQLDialect, MSSQL} from "@codemirror/lang-sql"
 import ist from "ist"
 
 function get(doc: string, conf: SQLConfig & {explicit?: boolean, keywords?: boolean} = {}) {
@@ -94,6 +94,11 @@ describe("SQL completion", () => {
     ist(str(get('select "other"."users"."|', {schema: schema2})), '"id", "name"')
   })
 
+  it("completes column names in bracket quoted tables with MSSQL", () => {
+    ist(str(get("select [public].[users].|", {schema: schema2, dialect: MSSQL})), "email, id")
+    ist(str(get("select [other].[users].|", {schema: schema2, dialect: MSSQL})), "id, name")
+  })
+
   it("completes column names of aliased tables", () => {
     ist(str(get("select u.| from users u", {schema: schema1})), "address, id, name")
     ist(str(get("select u.| from users as u", {schema: schema1})), "address, id, name")
@@ -126,6 +131,11 @@ describe("SQL completion", () => {
     ist(str(get('select a| from a.b as ab join auto au', {schema: schema2})), "ab, au, other, public")
   })
 
+  it("completes bracket quoted aliases with MSSQL", () => {
+    ist(str(get("select u.| from public.users [u]", {schema: schema2, dialect: MSSQL})), "email, id")
+    ist(str(get("select [u].| from public.users u", {schema: schema2, dialect: MSSQL})), "email, id")
+  })
+
   it("includes closing quote in completion", () => {
     let r = get('select "u|"', {schema: schema1})
     ist(r!.to, 10)
@@ -147,6 +157,7 @@ describe("SQL completion", () => {
 
   it("supports alternate quoting styles", () => {
     ist(str(get("select `u|", {dialect: MySQL, schema: schema1})), "`products`, `users`")
+    ist(str(get("select [u|", {dialect: MSSQL, schema: schema1})), "[products], [users]")
   })
 
   it("doesn't complete without identifier", () => {
@@ -173,6 +184,13 @@ describe("SQL completion", () => {
         'Column, cell')
   })
 
+  it("can add MSSQL-style brackets as identifier quotes", () => {
+    let dialect = SQLDialect.define({...MSSQL.spec, identifierQuotes: '['});
+    let config = { schema: {"Foo": ["Bar"]}, dialect: dialect };
+
+    ist(str(get("[Foo].b|", config)), "[Bar]");
+  })
+
   it("supports nesting more than two deep", () => {
     let s = {schema: {"one.two.three": ["four"]}}
     ist(str(get("o|", s)), "one")

test/test-tokens.ts

@@ -1,12 +1,13 @@
 import ist from "ist"
-import {PostgreSQL, MySQL, PLSQL, SQLDialect} from "@codemirror/lang-sql"
+import {PostgreSQL, MySQL, PLSQL, SQLDialect, MSSQL} from "@codemirror/lang-sql"
 
 const mysqlTokens = MySQL.language
 const postgresqlTokens = PostgreSQL.language
 const bigQueryTokens = SQLDialect.define({
   treatBitsAsBytes: true
 }).language
 const plsqlTokens = PLSQL.language
+const mssqlTokens = MSSQL.language
 
 describe("Parse MySQL tokens", () => {
   const parser = mysqlTokens.parser
@@ -91,3 +92,11 @@ describe("Parse PL/SQL tokens", () => {
     ist(parser.parse("SELECT q'~foo'bar' FROM DUAL"), 'Script(Statement(Keyword,String))')
   })
 })
+
+describe("Parse MSSQL tokens", () => {
+  const parser = mssqlTokens.parser;
+
+  it("parses brackets as QuotedIdentifier", () => {
+    ist(parser.parse("SELECT * FROM [tblTest]"), "Script(Statement(Keyword,Operator,Keyword,QuotedIdentifier))")
+  })
+})