Improve performance of completions

Performance is improved by initializing most of the completions related
stuff just after loading the identifiers, not each time a completion is
requested.
Also, slightly improves the performance of connection listing.

Author: tkopets

SQLTools.py

@@ -91,16 +91,17 @@ def getConnections():
         startPlugin()
 
     options = connections.get('connections', {})
+    allSettings = settings.all()
 
     for name, config in options.items():
-        connectionsObj[name] = createConnection(name, config, settings=settings.all())
+        connectionsObj[name] = createConnection(name, config, settings=allSettings)
 
     # project settings
     projectData = Window().project_data()
     if projectData:
         options = projectData.get('connections', {})
         for name, config in options.items():
-            connectionsObj[name] = createConnection(name, config, settings=settings.all())
+            connectionsObj[name] = createConnection(name, config, settings=allSettings)
 
     return connectionsObj
 
@@ -290,12 +291,12 @@ def getCurrentSyntax():
 
 
 class ST(EventListener):
+    connectionList   = None
     conn             = None
     tables           = []
     columns          = []
     functions        = []
-    connectionList   = None
-    autoCompleteList = []
+    completion       = None
 
     @staticmethod
     def bootstrap():
@@ -315,24 +316,49 @@ def checkDefaultConnection():
 
     @staticmethod
     def loadConnectionData(tablesCallback=None, columnsCallback=None, functionsCallback=None):
+        # clear the list of identifiers (in case connection is changed)
+        ST.tables = []
+        ST.columns = []
+        ST.functions = []
+        ST.completion = None
+
         if not ST.conn:
             return
 
         def tbCallback(tables):
-            setattr(ST, 'tables', tables)
+            ST.tables = tables
+
+            nonlocal callbacksRun
+            callbacksRun += 1
+            if callbacksRun == 3:
+                ST.completion = Completion(ST.tables, ST.columns, ST.functions, settings=settings)
+
             if tablesCallback:
                 tablesCallback()
 
         def colCallback(columns):
-            setattr(ST, 'columns', columns)
+            ST.columns = columns
+
+            nonlocal callbacksRun
+            callbacksRun += 1
+            if callbacksRun == 3:
+                ST.completion = Completion(ST.tables, ST.columns, ST.functions, settings=settings)
+
             if columnsCallback:
                 columnsCallback()
 
         def funcCallback(functions):
-            setattr(ST, 'functions', functions)
+            ST.functions = functions
+
+            nonlocal callbacksRun
+            callbacksRun += 1
+            if callbacksRun == 3:
+                ST.completion = Completion(ST.tables, ST.columns, ST.functions, settings=settings)
+
             if functionsCallback:
                 functionsCallback()
 
+        callbacksRun = 0
         ST.conn.getTables(tbCallback)
         ST.conn.getColumns(colCallback)
         ST.conn.getFunctions(funcCallback)
@@ -345,10 +371,6 @@ def setConnection(index, tablesCallback=None, columnsCallback=None, functionsCal
         connListNames = list(ST.connectionList.keys())
         connListNames.sort()
         ST.conn = ST.connectionList.get(connListNames[index])
-        # clear list of identifiers in case connection is changed
-        ST.tables = []
-        ST.columns = []
-        ST.functions = []
 
         ST.loadConnectionData(tablesCallback, columnsCallback, functionsCallback)
 
@@ -389,10 +411,21 @@ def on_query_completions(view, prefix, locations):
         if ST.conn is None:
             return None
 
+        if ST.completion is None:
+            return None
+
+        if ST.completion.isDisabled():
+            return None
+
         if not len(locations):
             return None
 
-        selectors = settings.get('selectors', [])
+        # disable completions inside strings
+        if view.match_selector(locations[0], 'string'):
+            return None
+
+        # show completions only for specific selectors
+        selectors = ST.completion.getSelectors()
         selectorMatched = False
         if selectors:
             for selector in selectors:
@@ -403,18 +436,6 @@ def on_query_completions(view, prefix, locations):
         if not selectorMatched:
             return None
 
-        # completions enabled? if yes, determine which type
-        completionType = settings.get('autocompletion', 'smart')
-        if not completionType:
-            return None         # autocompletion disabled
-        completionType = str(completionType).strip()
-        if completionType not in ['basic', 'smart']:
-            completionType = 'smart'
-
-        # no completions inside strings
-        if view.match_selector(locations[0], 'string'):
-            return None
-
         # sublimePrefix = prefix
         # sublimeCompletions = view.extract_completions(sublimePrefix, locations[0])
 
@@ -435,33 +456,24 @@ def on_query_completions(view, prefix, locations):
         except Exception as e:
             Log(e)
 
-        # determine desired keywords case from settings
-        formatSettings = settings.get('format', {})
-        keywordCase = formatSettings.get('keyword_case', 'upper')
-        uppercaseKeywords = keywordCase.lower().startswith('upper')
-
-        inhibit = False
-        completion = Completion(uppercaseKeywords, ST.tables, ST.columns, ST.functions)
+        # use current paragraph as sql text to parse
+        sqlRegion = expand_to_paragraph(view, currentPoint)
+        sql = view.substr(sqlRegion)
+        sqlToCursorRegion = sublime.Region(sqlRegion.begin(), currentPoint)
+        sqlToCursor = view.substr(sqlToCursorRegion)
 
-        if completionType == 'basic':
-            ST.autoCompleteList = completion.getBasicAutoCompleteList(prefix)
-        else:
-            # use current paragraph as sql text to parse
-            sqlRegion = expand_to_paragraph(view, currentPoint)
-            sql = view.substr(sqlRegion)
-            sqlToCursorRegion = sublime.Region(sqlRegion.begin(), currentPoint)
-            sqlToCursor = view.substr(sqlToCursorRegion)
-            ST.autoCompleteList, inhibit = completion.getAutoCompleteList(prefix, sql, sqlToCursor)
+        # get completions
+        autoCompleteList, inhibit = ST.completion.getAutoCompleteList(prefix, sql, sqlToCursor)
 
         # safe check here, so even if we return empty completions and inhibit is true
         # we return empty completions to show default sublime completions
-        if ST.autoCompleteList is None or len(ST.autoCompleteList) == 0:
+        if autoCompleteList is None or len(autoCompleteList) == 0:
             return None
 
         if inhibit:
-            return (ST.autoCompleteList, sublime.INHIBIT_WORD_COMPLETIONS)
+            return (autoCompleteList, sublime.INHIBIT_WORD_COMPLETIONS)
 
-        return ST.autoCompleteList
+        return autoCompleteList
 
 
 # #

SQLToolsAPI/Completion.py

@@ -161,11 +161,32 @@ def format(self, stripQuotes=False):
 
 
 class Completion:
-    def __init__(self, uppercaseKeywords, allTables, allColumns, allFunctions):
+    def __init__(self, allTables, allColumns, allFunctions, settings=None):
         self.allTables = [CompletionItem('Table', table) for table in allTables]
         self.allColumns = [CompletionItem('Column', column) for column in allColumns]
         self.allFunctions = [CompletionItem('Function', func) for func in allFunctions]
 
+        # we don't save the settings (we don't need them after init)
+        if settings is None:
+            settings = {}
+
+        # get completion selectors from settings
+        self.selectors = settings.get('selectors', [])
+
+        # determine type of completions
+        self.completionType = settings.get('autocompletion', 'smart')
+        if not self.completionType:
+            self.completionType = None  # autocompletion disabled
+        else:
+            self.completionType = str(self.completionType).strip()
+            if self.completionType not in ['basic', 'smart']:
+                self.completionType = 'smart'
+
+        # determine desired keywords case from settings
+        formatSettings = settings.get('format', {})
+        keywordCase = formatSettings.get('keyword_case', 'upper')
+        uppercaseKeywords = keywordCase.lower().startswith('upper')
+
         self.allKeywords = []
         for keyword in keywords_list:
             if uppercaseKeywords:
@@ -175,7 +196,34 @@ def __init__(self, uppercaseKeywords, allTables, allColumns, allFunctions):
 
             self.allKeywords.append(CompletionItem('Keyword', keyword))
 
-    def getBasicAutoCompleteList(self, prefix):
+    def getSelectors(self):
+        return self.selectors
+
+    def isDisabled(self):
+        return self.completionType is None
+
+    def getAutoCompleteList(self, prefix, sql, sqlToCursor):
+        if self.isDisabled():
+            return None
+
+        autocompleteList = []
+        inhibit = False
+        if self.completionType == 'smart':
+            autocompleteList, inhibit = self._getAutoCompleteListSmart(prefix, sql, sqlToCursor)
+        else:
+            autocompleteList = self._getAutoCompleteListBasic(prefix)
+
+        if not autocompleteList:
+            return None, False
+
+        # return completions with or without quotes?
+        # determined based on ident after last dot
+        startsWithQuote = _startsWithQuote(prefix.split(".").pop())
+        autocompleteList = [item.format(startsWithQuote) for item in autocompleteList]
+
+        return autocompleteList, inhibit
+
+    def _getAutoCompleteListBasic(self, prefix):
         prefix = prefix.lower()
         autocompleteList = []
 
@@ -198,13 +246,9 @@ def getBasicAutoCompleteList(self, prefix):
         if len(autocompleteList) == 0:
             return None
 
-        # return completions with or without quotes?
-        # determined based on ident after last dot
-        startsWithQuote = _startsWithQuote(prefix.split(".").pop())
-        autocompleteList = [item.format(startsWithQuote) for item in autocompleteList]
         return autocompleteList
 
-    def getAutoCompleteList(self, prefix, sql, sqlToCursor):
+    def _getAutoCompleteListSmart(self, prefix, sql, sqlToCursor):
         """
         Generally, we recognize 3 different variations in prefix:
           * ident|           // no dots (.) in prefix
@@ -262,10 +306,6 @@ def getAutoCompleteList(self, prefix, sql, sqlToCursor):
         if not autocompleteList:
             return None, False
 
-        # return completions with or without quotes?
-        # determined based on ident after last dot
-        startsWithQuote = _startsWithQuote(prefix.split(".").pop())
-        autocompleteList = [item.format(startsWithQuote) for item in autocompleteList]
         return autocompleteList, inhibit
 
     def _noDotsCompletions(self, prefix, identifiers, joinAlias=None):