Schema feature

.vscode/settings.json

@@ -5,5 +5,10 @@
     },
     "search.exclude": {
         "out": true // set this to false to include "out" folder in search results
-    }
+    },
+    "spellright.language": [
+      "en",
+    ],
+    "editor.tabSize": 2,
+    "editor.insertSpaces": true
 }

README.md

@@ -84,3 +84,4 @@ This extension contributes the following settings:
 * `vscode-postgres.virtualFolders`: set to array of virtual folders to be displayed under schema. Supported values for virtual folders are `functions`. Set to `null` or empty array `[]` to disable virtual folders.
 * `vscode-postgres.defaultConnection`: set the default connection (by name) that should be used for any file.
 * `vscode-postgres.defaultDatabase`: set the default database on the default connection that should be used for any file (must exist on server).
+* `vscode-postgres.defaultSchema`: set the default schema on the default connection that should be used for any file (must exist in the database). Skip to use public and all other schemas.

package.json

@@ -54,6 +54,11 @@
           "default": "",
           "description": "The default database on the default connection to use"
         },
+        "vscode-postgres.defaultSchema": {
+          "type": "string",
+          "default": "",
+          "description": "The default schema on the default connection to use (empty to use all)"
+        },
         "vscode-postgres.showExplorer": {
           "type": "boolean",
           "default": true,

src/commands/selectConnection.ts

@@ -47,11 +47,13 @@ export class selectConnectionCommand extends BaseCommand {
       }
       EditorState.connection = connection;
       await vscode.commands.executeCommand('vscode-postgres.selectDatabase');
+      await vscode.commands.executeCommand('vscode-postgres.selectSchema');
       return;
     }
 
     let result = await vscode.commands.executeCommand('vscode-postgres.addConnection');
     if (!result) return;
     await vscode.commands.executeCommand('vscode-postgres.selectDatabase');
+    await vscode.commands.executeCommand('vscode-postgres.selectSchema');
   }
 }

src/commands/selectSchema.ts

@@ -0,0 +1,31 @@
+import BaseCommand from "../common/baseCommand";
+import * as vscode from 'vscode';
+import { IConnection } from "../common/IConnection";
+import { EditorState } from "../common/editorState";
+import { Database } from "../common/database";
+
+'use strict';
+
+export class selectSchemaCommand extends BaseCommand {
+  async run() {
+    // vscode.window.showInformationMessage('Select Database!');
+    let connectionDetails: IConnection = EditorState.connection;
+    if (!connectionDetails) return;
+
+    const connection = await Database.createConnection(connectionDetails, connectionDetails.database);
+
+    let schemas: string[] = [];
+    try {
+      const res = await connection.query('SELECT schema_name as sch FROM information_schema.schemata;');
+      schemas = res.rows.map<string>(schema => schema.sch);
+    } finally {
+      await connection.end();
+    }
+
+    //vscode.window.showInputBox
+    const schema = await vscode.window.showQuickPick(schemas, {placeHolder: 'Select a schema'});
+    if (!schema) return;
+    connectionDetails.schema = schema;
+    EditorState.connection = Database.getConnectionWithDB(connectionDetails, connectionDetails.database);
+  }
+}

src/common/IConnection.ts

@@ -6,6 +6,7 @@ export interface IConnection {
   hasPassword?: boolean;
   readonly port: number;
   readonly database?: string;
+  schema?: string;
   multipleStatements?: boolean;
   readonly certPath?: string;
   ssl?: any;

src/common/database.ts

@@ -64,6 +64,7 @@ export class Database {
       password: connection.password,
       port: connection.port,
       database: dbname,
+      schema: connection.schema,
       multipleStatements: connection.multipleStatements,
       certPath: connection.certPath
     };
@@ -72,6 +73,7 @@ export class Database {
   public static async createConnection(connection: IConnection, dbname?: string): Promise<PgClient> {
     const connectionOptions: any = Object.assign({}, connection);
     connectionOptions.database = dbname ? dbname : connection.database;
+    connectionOptions.schema = connection.schema;
     if (connectionOptions.certPath && fs.existsSync(connectionOptions.certPath)) {
       connectionOptions.ssl = {
         ca: fs.readFileSync(connectionOptions.certPath).toString(),

src/common/editorState.ts

@@ -81,6 +81,12 @@ export class EditorState {
       }
     }
 
+    // optional schema
+    let defaultSchema = Global.Configuration.get<string>("defaultSchema");
+    if (typeof defaultSchema === 'string' && defaultSchema.length) {
+      connection.schema = defaultSchema;
+    }
+
     let defaultDatabase = Global.Configuration.get<string>("defaultDatabase");
     if (defaultDatabase) {
       const conn = await Database.createConnection(connection, 'postgres');

src/language/server.ts

@@ -145,6 +145,7 @@ async function setupDBConnection(connectionOptions: IDBConnection, uri: string):
         password: connectionOptions.password,
         port: connectionOptions.port,
         database: 'postgres',
+        schema: '',
         multipleStatements: connectionOptions.multipleStatements,
         certPath: connectionOptions.certPath,
         ssl: connectionOptions.ssl
@@ -199,6 +200,7 @@ async function loadCompletionCache(connectionOptions: IDBConnection) {
 
   try {
     if (connectionOptions.database) {
+      let schema = (typeof connectionOptions.schema === 'string' && connectionOptions.schema.length) ? connectionOptions.schema : false;
       /*
       SELECT tablename as name, true as is_table FROM pg_tables WHERE schemaname not in ('information_schema', 'pg_catalog')
       union all
@@ -223,6 +225,7 @@ async function loadCompletionCache(connectionOptions: IDBConnection) {
               JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
             WHERE
               c.relkind = 'r'
+              ${schema? "AND n.nspname = '"+schema+"'" : ''}
               AND n.nspname not in ('information_schema', 'pg_catalog', 'pg_toast')
               AND n.nspname not like 'pg_temp_%'
               AND n.nspname not like 'pg_toast_temp_%'
@@ -240,6 +243,7 @@ async function loadCompletionCache(connectionOptions: IDBConnection) {
               JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
             WHERE
               c.relkind in ('v', 'm')
+              ${schema? "AND n.nspname = '"+schema+"'" : ''}
               AND n.nspname not in ('information_schema', 'pg_catalog', 'pg_toast')
               AND n.nspname not like 'pg_temp_%'
               AND n.nspname not like 'pg_toast_temp_%'