SAP Hana dialect

.gitignore

@@ -16,4 +16,5 @@ cache/
 *.db
 *.zip
 .test-database/oracle/docker-images-master
-.test-database/**/local*
+.test-database/**/local*
+.DS_Store

.test-database/.vscode/settings.json

@@ -120,5 +120,16 @@
         "authProtocol": "xprotocol"
       }
     },
+    {
+      "askForPassword": false,
+      "connectionTimeout": 30,
+      "database": "98D27766B06E45F9A78EA36D5D6C3A5B",
+      "dialect": "SAPHana",
+      "name": "Hana",
+      "password": "Tg6cdRmULar3.yQcw4kVh.SeFNaF._iPaWLFdDvB94_C2jNnVB25reG63nSUkMs.DPFllAJHKwsRCRz1qtgGQrc4t81H8eLpGq3pUsMi9IUrwWZoabdLUHM3FHyhEOee",
+      "port": 30041,
+      "server": "127.0.0.1",
+      "username": "SBSS_51921077446042462816087486121804932303752819285673181439206685123"
+    }
   ]
 }

docs/Connections.md

@@ -4,4 +4,5 @@
 * [MySQL](Connections/mysql.md)
 * [Oracle Database](Connections/OracleDB.md)
 * [PostgreSQL](Connections/postgresql.md)
-* [SQLite](Connections/SQLite.md)
+* [SQLite](Connections/SQLite.md)
+* [SAP HANA](Connections/SAPHANA.md)

docs/Connections/SAPHANA.md

@@ -0,0 +1,35 @@
+# SAP HANA Start Guide
+
+## 1. Prerequisites
+
+> Extension automatically asks to install the SAP HANA driver (@sap/sap-client)
+
+## 2. Connections
+
+### 2.1 SAP HANA Connection
+
+For full reference, see [SAP Documentation](https://help.sap.com/viewer/0eec0d68141541d1b07893a39944924e/2.0.02/en-US/4fe9978ebac44f35b9369ef5a4a26f4c.html)
+
+```json
+{
+  "name": "<your prefered name>",
+  "dialect": "SAPHana",
+  "database": "<the schema you want to connect to>", 
+  "username": "<user-name",
+  "password": "<pwd>",
+  "connectionTimeout": 15 //in seconds,0 for disabling
+}
+```
+
+
+### 2.2 Alternative Connection Strings
+
+ConnectionString maps from `connectString` property:
+
+```json
+{
+  "name": "<your prefered name>",
+  "dialect": "SAPHana",
+  "connectString": "<see docs>" // Example: "connectString": "HOST=myServer;PORT=30015;UID=MyUser;PWD=MyPassword"
+}
+```

docs/SUMMARY.md

@@ -7,6 +7,7 @@
   * [Oracle Database](Connections/OracleDB.md)
   * [PostgreSQL](Connections/postgresql.md)
   * [SQLite](Connections/SQLite.md)
+  * [SAP HANA](Connections/SAPHANA.md)
 * [Executing Queries](executing-queries.md)
 * [Codelens](codelens.md)
 * [Contributing](Contributing.md)

packages/core/.vscode/launch.json

@@ -0,0 +1,23 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "type": "node",
+            "request": "attach",
+            "name": "Attach by Process ID",
+            "processId": "${command:PickProcess}"
+        },
+        {
+            "type": "node",
+            "request": "launch",
+            "name": "Launch Program",
+            "program": "${workspaceFolder}/index.ts",
+            "outFiles": [
+                "${workspaceFolder}/**/*.js"
+            ]
+        }
+    ]
+}

packages/core/dialect/generic.ts

@@ -13,6 +13,7 @@ export interface Deps {
   name: string;
   version?: string;
   env?: { [id: string]: string };
+  args?: string[], // extra arguments to be passaged to packag managers
 }
 
 export default abstract class GenericDialect<ConnectionType extends any> implements ConnectionDialect {

packages/core/dialect/index.ts

@@ -3,13 +3,14 @@ import MySQL from './mysql';
 import OracleDB from './oracle';
 import PostgreSQL from './pgsql';
 import SQLite from './sqlite';
-
+import SAPHana from './saphana';
 const dialects = {
   MSSQL,
   MySQL,
   PostgreSQL,
   OracleDB,
   SQLite,
+  SAPHana
 };
 
 export default dialects;

packages/core/dialect/saphana/debug.js

@@ -0,0 +1,5 @@
+module.exports = function (ns){
+    return function (args) {
+        //do nothing
+    }
+};

packages/core/dialect/saphana/index.ts

@@ -0,0 +1,208 @@
+
+import {
+  ConnectionDialect
+} from '@sqltools/core/interface';
+import * as Utils from '@sqltools/core/utils';
+import queries from './queries';
+import GenericDialect from '@sqltools/core/dialect/generic';
+import { DatabaseInterface } from '@sqltools/core/plugin-api';
+
+interface Statement {
+  exec(params: any[], handler: (err: any, row: any) => void);
+}
+
+interface HanaClientModule {
+  createConnection(connOptions: object): HanaConnection;
+}
+
+interface HanaConnection {
+  connect(handler: (err: any) => void);
+  exec(query: string, handler: (err: any, row: any) => void);
+  disconnect();
+  prepare(query: string, handler: (err: any, statement: Statement) => void);
+}
+
+export default class SAPHana extends GenericDialect<HanaConnection> implements ConnectionDialect {
+
+  public static deps: typeof GenericDialect['deps'] = [{
+    type: 'package',
+    name: '@sap/hana-client',
+    version: '2.4.126',
+    args: ['--@sap:registry=https://npm.sap.com']
+  }];
+
+  private get lib() {
+    return __non_webpack_require__('@sap/hana-client') as HanaClientModule;
+  }
+
+  queries = queries;
+  private schema: String;
+
+  public open(encrypt?: boolean): Promise<HanaConnection> {
+    if (this.connection) {
+      return this.connection;
+    }
+
+    this.needToInstallDependencies();
+
+    const connOptions = {
+      HOST: this.credentials.server,
+      PORT: this.credentials.port,
+      UID: this.credentials.username,
+      PWD: this.credentials.password
+    }
+    if (this.credentials.connectionTimeout && this.credentials.connectionTimeout > 0) {
+      connOptions["CONNECTTIMEOUT"] = this.credentials.connectionTimeout * 1000;
+    }
+    if (encrypt) {
+      connOptions["ENCRYPT"] = true;
+    }
+
+    try {
+      let conn = this.lib.createConnection(connOptions);
+
+      this.connection = new Promise<HanaConnection>((resolve, reject) => conn.connect(err => {
+        if (err) {
+          console.error("Connection to HANA failed", err.toString());
+          reject(err);
+        }
+        this.schema = this.credentials.database;
+        conn.exec("SET SCHEMA " + this.schema, err => {
+            if (err) {
+              reject(err);
+            }
+            console.log("Connection to SAP Hana succedded!");
+            resolve(conn);
+          });
+      }));
+      return this.connection;
+    } catch (e) {
+      console.error("Connection to HANA failed" + e.toString());
+      Promise.reject(e);
+    }
+  }
+
+  public async close() {
+    if (!this.connection) return Promise.resolve();
+
+    await this.connection.then(conn => conn.disconnect());
+    this.connection = null;
+  }
+
+  public async testConnection?() {
+    return this.open().then(conn => conn.exec('select 1 from dummy;', (err, rows) => rows));
+  }
+
+  public query(query: string, args?): Promise<DatabaseInterface.QueryResults[]> {
+    return this.open().then(conn => {
+      return new Promise<DatabaseInterface.QueryResults[]>((resolve, reject) => {
+        if (args) {
+          conn.prepare(query, (err, statement) => {
+            if (err) {
+              return this.resolveErr(resolve, err, query);
+            }
+            statement.exec(args, (err, rows) => {
+              if (err) {
+                return this.resolveErr(resolve, err, query);
+              }
+              return this.resolveQueryResults(resolve, rows, query);
+            });
+          });
+        } else {
+          conn.exec(query, (err, rows) => {
+            if (err) {
+              return this.resolveErr(resolve, err, query);
+            }
+            return this.resolveQueryResults(resolve, rows, query);
+          });
+        }
+      });
+    });
+  }
+
+  private resolveQueryResults(resolve, rows, query) {
+    let cols: string[] = [];
+    if (rows && rows.length > 0) {
+      for (let colName in rows[0]) {
+        cols.push(colName);
+      }
+    }
+
+    let res = {
+      connId: this.getId(),
+      results: rows,
+      cols: cols,
+      query: query,
+      messages: []
+    } as DatabaseInterface.QueryResults
+
+    return resolve([res]);
+  }
+
+  private resolveErr(resolve, err, query) {
+    let messages: string[] = [];
+    if (err.message) {
+      messages.push(err.message);
+    }
+
+    return resolve([{
+      connId: this.getId(),
+      error: err,
+      results: [],
+      cols: [],
+      query: query,
+      messages: messages
+    } as DatabaseInterface.QueryResults]);
+  }
+
+  public getTables(): Promise<DatabaseInterface.Table[]> {
+    return this.query(this.queries.fetchTables, [this.schema])
+      .then(([queryRes]) => {
+        return queryRes.results
+          .reduce((prev, curr) => prev.concat(curr), [])
+          .map((obj) => {
+            return {
+              name: obj.TABLENAME,
+              isView: !!obj.ISVIEW,
+              numberOfColumns: parseInt(obj.NUMBEROFCOLUMNS, 10),
+              tableCatalog: obj.TABLECATALOG,
+              tableDatabase: obj.DBNAME,
+              tableSchema: obj.TABLESCHEMA,
+              tree: obj.TREE,
+            } as DatabaseInterface.Table;
+          });
+      });
+  }
+
+  public getColumns(): Promise<DatabaseInterface.TableColumn[]> {
+    return this.query(this.queries.fetchColumns, [this.schema])
+      .then(([queryRes]) => {
+        return queryRes.results
+          .reduce((prev, curr) => prev.concat(curr), [])
+          .map((obj) => {
+            return {
+              columnName: obj.COLUMNNAME,
+              defaultValue: obj.DEFAULTVALUE,
+              isNullable: !!obj.ISNULLABLE ? obj.ISNULLABLE.toString() === 'yes' : null,
+              size: obj.SIZE !== null ? parseInt(obj.SIZE, 10) : null,
+              tableCatalog: obj.TABLECATALOG,
+              tableDatabase: obj.DBNAME,
+              tableName: obj.TABLENAME,
+              tableSchema: obj.TABLESCHEMA,
+              isPk: (obj.KEYTYPE || '').toLowerCase() === 'primary key',
+              isFk: (obj.KEYTYPE || '').toLowerCase() === 'foreign key',
+              type: obj.TYPE,
+              tree: obj.TREE,
+            } as DatabaseInterface.TableColumn;
+          });
+      });
+  }
+
+  public async getFunctions() {
+    return [];
+  }
+
+  public describeTable(prefixedTable: string) {
+    return this.query(this.queries.describeTable, [this.schema, prefixedTable]);
+  }
+}