Improvements for looking up pasted code

Signed-off-by: worksofliam <[email protected]>

Author: worksofliam

src/language/providers/hoverProvider.ts

@@ -25,7 +25,7 @@ export const openProvider = workspace.onDidOpenTextDocument(async (document) =>
             if (first.object.name) {
               const name = Statement.noQuotes(Statement.delimName(first.object.name, true));
               const schema = Statement.noQuotes(Statement.delimName(first.object.schema || defaultSchema, true));
-              const result = await DbCache.getType(schema, name, `PROCEDURE`);
+              const result = await DbCache.getRoutine(schema, name, `PROCEDURE`);
               if (result) {
                 await DbCache.getSignaturesFor(schema, name, result.specificNames);
               }
@@ -37,7 +37,7 @@ export const openProvider = workspace.onDidOpenTextDocument(async (document) =>
                 const name = Statement.noQuotes(Statement.delimName(ref.object.name, true));
                 const schema = Statement.noQuotes(Statement.delimName(ref.object.schema || defaultSchema, true));
                 if (ref.isUDTF) {
-                  const result = await DbCache.getType(schema, name, `FUNCTION`);
+                  const result = await DbCache.getRoutine(schema, name, `FUNCTION`);
                   if (result) {
                     await DbCache.getSignaturesFor(schema, name, result.specificNames);
                   }
@@ -74,9 +74,11 @@ export const hoverProvider = languages.registerHoverProvider({ language: `sql` }
 
         if (atRef) {
           const schema = ref.object.schema || defaultSchema;
-          const result = lookupSymbol(ref.object.name, schema, possibleNames);
+          const result = await lookupSymbol(ref.object.name, schema, possibleNames);
           if (result) {
             addSymbol(md, result);
+          } else {
+            
           }
 
           if (systemSchemas.includes(schema.toUpperCase())) {
@@ -87,7 +89,7 @@ export const hoverProvider = languages.registerHoverProvider({ language: `sql` }
 
       // If no symbol found, check if we can find a symbol by name
       if (md.value.length === 0 && tokAt && tokAt.type === `word` && tokAt.value) {
-        const result = lookupSymbol(tokAt.value, defaultSchema, possibleNames);
+        const result = await lookupSymbol(tokAt.value, undefined, possibleNames);
         if (result) {
           addSymbol(md, result);
         }
@@ -147,9 +149,9 @@ function addSymbol(base: MarkdownString, symbol: LookupResult) {
   }
 }
 
-function lookupSymbol(name: string, schema: string, possibleNames: string[]) {
+function lookupSymbol(name: string, schema: string|undefined, possibleNames: string[]) {
   name = Statement.noQuotes(Statement.delimName(name, true));
-  schema = Statement.noQuotes(Statement.delimName(schema, true));
+  schema = schema ? Statement.noQuotes(Statement.delimName(schema, true)) : undefined
 
   return DbCache.lookupSymbol(name, schema, possibleNames);
 }

src/language/providers/logic/cache.ts

@@ -40,27 +40,37 @@ export class DbCache {
     return false;
   }
 
-  static lookupSymbol(name: string, schema: string, objectFilter: string[]): LookupResult {
-    const routine = this.getCachedType(schema, name, `FUNCTION`) || this.getCachedType(schema, name, `PROCEDURE`);
-    if (routine) {
-      const signatures = this.getCachedSignatures(schema, name);
-      return { routine, signatures } as RoutineDetail;
-    }
-
-    objectFilter = objectFilter.map(o => o.toLowerCase());
-
-    const included = (name: string) => {
+  static async lookupSymbol(name: string, schema: string|undefined, objectFilter: string[]): Promise<LookupResult> {
+    const included = (lookupName: string) => {
       if (objectFilter) {
-        return objectFilter.includes(name.toLowerCase());
+        return objectFilter.includes(lookupName.toLowerCase());
       }
       return true;
     }
 
-    // Search objects
-    for (const currentSchema of this.schemaObjects.values()) {
-      const chosenObject = currentSchema.find(sqlObject => included(sqlObject.name) && sqlObject.name === name && sqlObject.schema === schema);
-      if (chosenObject) {
-        return chosenObject;
+    if (schema) {
+      // Looking routine
+      const routine = this.getCachedRoutine(schema, name, `FUNCTION`) || this.getCachedRoutine(schema, name, `PROCEDURE`);
+      if (routine) {
+        const signatures = this.getCachedSignatures(schema, name);
+        return { routine, signatures } as RoutineDetail;
+      }
+
+      objectFilter = objectFilter.map(o => o.toLowerCase());
+
+      // Search objects
+      for (const currentSchema of this.schemaObjects.values()) {
+        const chosenObject = currentSchema.find(sqlObject => included(sqlObject.name) && sqlObject.name === name && sqlObject.schema === schema);
+        if (chosenObject) {
+          return chosenObject;
+        }
+      }
+
+      // Finally, let's do a last lookup
+      const lookupRoutine = await this.getRoutine(schema, name, `FUNCTION`) || await this.getRoutine(schema, name, `PROCEDURE`);
+      if (lookupRoutine) {
+        const signatures = await this.getSignaturesFor(schema, name, lookupRoutine.specificNames);
+        return { routine: lookupRoutine, signatures } as RoutineDetail;
       }
     }
 
@@ -111,7 +121,7 @@ export class DbCache {
     return this.schemaObjects.get(key) || [];
   }
 
-  static async getType(schema: string, name: string, type: CallableType) {
+  static async getRoutine(schema: string, name: string, type: CallableType) {
     const key = getKey(type, schema, name);
 
     if (!this.routines.has(key) || this.shouldReset(name)) {
@@ -127,7 +137,7 @@ export class DbCache {
     return this.routines.get(key) || undefined;
   }
 
-  static getCachedType(schema: string, name: string, type: CallableType) {
+  static getCachedRoutine(schema: string, name: string, type: CallableType) {
     const key = getKey(type, schema, name);
     return this.routines.get(key) || undefined
   }

src/language/providers/logic/callable.ts

@@ -14,7 +14,7 @@ export async function isCallableType(ref: ObjectRef, type: CallableType) {
     ref.object.schema = Statement.noQuotes(Statement.delimName(ref.object.schema, true));
     ref.object.name = Statement.noQuotes(Statement.delimName(ref.object.name, true));
 
-    const callableRoutine = await DbCache.getType(ref.object.schema, ref.object.name, type);
+    const callableRoutine = await DbCache.getRoutine(ref.object.schema, ref.object.name, type);
 
     if (callableRoutine) {
       await DbCache.getSignaturesFor(ref.object.schema, ref.object.name, callableRoutine.specificNames);