dbmetadata: Now case insensitive

Rather than nested dict, example {"table": {"AdventureWorks2017":
{"Person": {"Address": {}}, ...}, ...}, ...} to represent

AdventureWorks2017.Person.Address

Now: {"table": {"adventureworks2017": ("AdventureWorks2017": {"person":
("Person", {...}), ... )}.

That is to say, whereas previously we had [cased]: {}, each entry is now
[lowercase]: ([cased], {...}).

Author: detule

odbcli/completion/mssqlcompleter.py

@@ -172,6 +172,8 @@ def extend_casing(self, words):
         self.casing = dict((word.lower(), word) for word in words)
 
     def extend_functions(self, func_data):
+        """ OG: Currently not used
+        """
 
         # func_data is a list of function metadata namedtuples
 
@@ -195,6 +197,8 @@ def extend_functions(self, func_data):
         self._refresh_arg_list_cache()
 
     def _refresh_arg_list_cache(self):
+        """ OG: Currently not used
+        """
         # We keep a cache of {function_usage:{function_metadata: function_arg_list_string}}
         # This is used when suggesting functions, to avoid the latency that would result
         # if we'd recalculate the arg lists each time we suggest functions (in
@@ -212,6 +216,8 @@ def _refresh_arg_list_cache(self):
         }
 
     def extend_foreignkeys(self, fk_data):
+        """ OG: Currently not used
+        """
 
         # fk_data is a list of ForeignKey namedtuples, with fields
         # parentschema, childschema, parenttable, childtable,
@@ -237,6 +243,8 @@ def extend_foreignkeys(self, fk_data):
             parcolmeta.foreignkeys.append((fk))
 
     def extend_datatypes(self, type_data):
+        """ OG: Currently not used
+        """
 
         # dbmetadata['datatypes'][schema_name][type_name] should store type
         # metadata, such as composite type field names. Currently, we're not
@@ -576,7 +584,7 @@ def get_join_matches(self, suggestion, word_before_cursor):
 
     def get_join_condition_matches(self, suggestion, word_before_cursor):
         col = namedtuple('col', 'schema tbl col')
-        tbls = self.populate_scoped_cols(suggestion.table_refs).items
+        tbls = self.populate_scoped_cols2(suggestion.table_refs).items
         cols = [(t, c) for t, cs in tbls() for c in cs]
         try:
             lref = (suggestion.parent or suggestion.table_refs[-1]).ref
@@ -630,8 +638,9 @@ def list_dict(pairs):  # Turns [(a, b), (a, c)] into {a: [b, c]}
     # TODO: Need to account for suggestion.catalog
     def get_function_matches(
             self, suggestion, word_before_cursor, alias=False):
-
-        # OG: hack early exit, for now
+        """ OG: currently not used / hacked to exit early
+        """
+        # OG: hack early exit
         return []
         # We'll have to do away with this right? How can we possibly know this
         if suggestion.usage == 'from':
@@ -668,8 +677,6 @@ def filt(_):
 
     def get_schema_matches(self, suggestion, word_before_cursor):
         conn = self.active_conn
-        metadata = conn.dbmetadata.data
-        submeta = metadata['table']
         if suggestion.parent:
             catalog_u = self.unescape_name(suggestion.parent)
         else:
@@ -830,7 +837,6 @@ def get_alias_matches(self, suggestion, word_before_cursor):
 
     def get_database_matches(self, _, word_before_cursor):
         conn = self.active_conn
-        metadata = conn.dbmetadata.data
         catalogs_e = conn.dbmetadata.get_catalogs()
         if catalogs_e is None and (conn.connected()):
             catalogs_e = self.escape_names(conn.list_catalogs())
@@ -879,6 +885,8 @@ def get_special_matches(self, _, word_before_cursor):
         return self.find_matches(word_before_cursor, cmds, mode='strict')
 
     def get_datatype_matches(self, suggestion, word_before_cursor):
+        """ OG: Currently not used
+        """
         # suggest custom datatypes
         types = self.populate_schema_objects(suggestion.schema, 'datatypes')
         types = [self._make_cand(t, False, suggestion) for t in types]
@@ -909,7 +917,7 @@ def get_datatype_matches(self, suggestion, word_before_cursor):
         Database: get_database_matches,
         Keyword: get_keyword_matches,
         Special: get_special_matches,
-        Datatype: get_datatype_matches,
+#        Datatype: get_datatype_matches,
 #        NamedQuery: get_namedquery_matches,
         Path: get_path_matches,
     }
@@ -1027,7 +1035,8 @@ def addcols(catalog, schema, rel, alias, reltype, cols):
         return columns
 
     def _get_schemas(self, obj_typ, schema):
-        """Returns a list of schemas from which to suggest objects.
+        """ OG: Currently not used
+            Returns a list of schemas from which to suggest objects.
 
         :param schema is the schema qualification input by the user (if any)
 
@@ -1044,7 +1053,8 @@ def _maybe_schema(self, schema, parent):
         return None if parent or schema in self.search_path else schema
 
     def populate_schema_objects(self, schema, obj_type):
-        """Returns a list of SchemaObjects representing tables or views.
+        """ OG: Currently not used
+            Returns a list of SchemaObjects representing tables or views.
 
         :param schema is the schema qualification input by the user (if any)
 
@@ -1070,8 +1080,6 @@ def populate_objects(self, catalog, schema, obj_type):
         ret = []
         obj_names = []
         conn = self.active_conn
-        metadata = conn.dbmetadata.data
-        submeta = metadata[obj_type]
         self.logger.debug("populate_objects(%s): Called for %s.%s",
                 obj_type, catalog, schema)
         if catalog is None and schema is None:
@@ -1144,7 +1152,8 @@ def populate_objects(self, catalog, schema, obj_type):
         return ret
 
     def populate_functions(self, schema, filter_func):
-        """Returns a list of function SchemaObjects.
+        """ OG: currently not used.
+            Returns a list of function SchemaObjects.
 
         :param filter_func is a function that accepts a FunctionMetadata
         namedtuple and returns a boolean indicating whether that

odbcli/dbmetadata.py

@@ -10,65 +10,81 @@ def extend_catalogs(self, names: list) -> None:
         with self._lock:
             for metadata in self._dbmetadata.values():
                 for catalog in names:
-                    metadata[catalog] = {}
+                    metadata[catalog.lower()] = (catalog, {})
         return
 
-    def get_catalogs(self, obj_type: str = "table") -> list:
+    def get_catalogs(self, obj_type: str = "table", cased: bool = True) -> list:
         """ Retrieve catalogs as the keys for _dbmetadata[obj_type]
             If no keys are found it returns None.
         """
         with self._lock:
-            res = self._dbmetadata[obj_type].keys()
+            if cased:
+                res = [casedkey for casedkey, mappedvalue in self._dbmetadata[obj_type].values()]
+            else:
+                res = list(self._dbmetadata[obj_type].keys())
+
 
         if len(res) == 0:
             return None
 
-        return list(res)
+        return res
 
     def extend_schemas(self, catalog, names: list) -> None:
         """ This method will force/create [catalog] dictionary
             in the event that len(names) > 0, and overwrite if
             anything was there to begin with.
         """
+        catlower = catalog.lower()
+        cat_cased = catalog
         if len(names):
             with self._lock:
                 for metadata in self._dbmetadata.values():
-                    metadata[catalog] = {}
+                    # Preserve casing if an entry already there
+                    if catlower in metadata.keys() and len(metadata[catlower]):
+                        cat_cased = metadata[catlower][0]
+                    metadata[catlower] = (cat_cased, {})
                     for schema in names:
-                        metadata[catalog][schema] = {}
+                        metadata[catlower][1][schema.lower()] = (schema, {})
         return
 
-    def get_schemas(self, catalog: str, obj_type: str = "table") -> list:
+    def get_schemas(self, catalog: str, obj_type: str = "table", cased: bool = True) -> list:
         """ Retrieve schemas as the keys for _dbmetadata[obj_type][catalog]
             If catalog is not part of the _dbmetadata[obj_type] keys will return
             None.
         """
 
-        cats = self.get_catalogs(obj_type = obj_type)
-        if cats is None or catalog not in cats:
+        catlower = catalog.lower()
+        cats = self.get_catalogs(obj_type = obj_type, cased = False)
+        if cats is None or catlower not in cats:
             return None
 
         with self._lock:
-            res = self._dbmetadata[obj_type][catalog].keys()
+            if cased:
+                res = [casedkey for casedkey, mappedvalue in self._dbmetadata[obj_type][catlower][1].values()]
+            else:
+                res = list(self._dbmetadata[obj_type][catlower][1].keys())
 
-        return list(res)
+
+        return res
 
     def extend_objects(self, catalog, schema, names: list, obj_type: str) -> None:
+        catlower = catalog.lower()
+        schlower = schema.lower()
         if len(names):
             with self._lock:
-                for metadata in self._dbmetadata.values():
+                for otype in self._dbmetadata.keys():
                     # Loop over tables, views, functions
-                    if catalog not in metadata.keys():
-                        metadata[catalog] = {}
-                    if schema not in metadata[catalog].keys():
-                        metadata[catalog][schema] = {}
+                    if catlower not in self._dbmetadata[otype].keys():
+                        self._dbmetadata[otype][catlower] = (catalog, {})
+                    if schlower not in self._dbmetadata[otype][catlower][1].keys():
+                        self._dbmetadata[otype][catlower][1][schlower] = (schema, {})
                 for obj in names:
-                    self._dbmetadata[obj_type][catalog][schema][obj] = {}
+                    self._dbmetadata[obj_type][catlower][1][schlower][1][obj.lower()] = (obj, {})
         # If we passed nothing then take out that element entirely out
         # of the dict
         else:
             with self._lock:
-                del self._dbmetadata[obj_type][catalog][schema]
+                del self._dbmetadata[obj_type][catlower][1][schlower]
 
         return
 
@@ -78,12 +94,14 @@ def get_objects(self, catalog: str, schema: str, obj_type: str = "table") -> lis
             not one of the keys in _dbmetadata[obj_type][catalog] will return None
         """
 
-        schemas = self.get_schemas(catalog = catalog, obj_type = obj_type)
-        if schemas is None or schema not in schemas:
+        catlower = catalog.lower()
+        schlower = schema.lower()
+        schemas = self.get_schemas(catalog = catalog, obj_type = obj_type, cased = False)
+        if schemas is None or schlower not in schemas:
             return None
 
         with self._lock:
-            res = self._dbmetadata[obj_type][catalog][schema].keys()
+            res = [casedkey for casedkey, mappedvalue in self._dbmetadata[obj_type][catlower][1][schlower][1].values()]
 
         return list(res)