Merge pull request #191 from mtxr/feature/improve-completions-speed

Improve completions and connections listing performance

Author: tkopets

Default.sublime-commands

@@ -32,8 +32,8 @@
     "command": "st_desc_function"
   },
   {
-    "caption": "ST: Remove Table and Functions cache",
-    "command": "st_clear_cache"
+    "caption": "ST: Refresh Connection Data",
+    "command": "st_refresh_connection_data"
   },
   {
     "caption": "ST: Save Query",

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,21 +316,46 @@ 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
+        callbacksRun = 0
+
         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()
 
@@ -345,18 +371,8 @@ def setConnection(index, tablesCallback=None, columnsCallback=None, functionsCal
         connListNames = list(ST.connectionList.keys())
         connListNames.sort()
         ST.conn = ST.connectionList.get(connListNames[index])
-        ST.reset_cache(tablesCallback, columnsCallback, functionsCallback)
-
-        Log('Connection {0} selected'.format(ST.conn))
-
-    @staticmethod
-    def reset_cache(tablesCallback=None, columnsCallback=None, functionsCallback=None):
-        # clear list of identifiers in case connection is changed
-        ST.tables = []
-        ST.columns = []
-        ST.functions = []
-
         ST.loadConnectionData(tablesCallback, columnsCallback, functionsCallback)
+        Log('Connection {0} selected'.format(ST.conn))
 
     @staticmethod
     def selectConnection(tablesCallback=None, columnsCallback=None, functionsCallback=None):
@@ -393,10 +409,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:
@@ -407,18 +434,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])
 
@@ -439,33 +454,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')
+        # 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)
 
-        inhibit = False
-        completion = Completion(uppercaseKeywords, ST.tables, ST.columns, ST.functions)
-
-        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
 
 
 # #
@@ -544,12 +550,14 @@ def cb(index):
         # from "function_name(int)"
         ST.selectFunction(cb)
 
-class StClearCache(WindowCommand):
+
+class StRefreshConnectionData(WindowCommand):
     @staticmethod
     def run():
         if not ST.conn:
             return
-        ST.reset_cache()
+        ST.loadConnectionData()
+
 
 class StExplainPlan(WindowCommand):
     @staticmethod

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):