@abaplint/transpiler 2.7.88 → 2.7.90

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Lars Hvam Petersen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/build/src/db/database_setup_result.d.ts

@@ -3,6 +3,7 @@ export type DatabaseSetupResult = {
         sqlite: string[];
         pg: string[];
         hdb: string[];
+        snowflake: string[];
     };
     insert: string[];
 };

package/build/src/db/index.d.ts

@@ -5,6 +5,7 @@ export declare class DatabaseSetup {
     private readonly reg;
     constructor(reg: abaplint.IRegistry);
     run(options?: ITranspilerOptions | undefined): DatabaseSetupResult;
+    private driver;
     private buildInsert;
     private insertREPOSRC;
     private insertT000;

package/build/src/db/index.js

@@ -3,8 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DatabaseSetup = void 0;
 /* eslint-disable max-len */
 const abaplint = require("@abaplint/core");
-const sqlite_database_schema_1 = require("./sqlite_database_schema");
-const pg_database_schema_1 = require("./pg_database_schema");
+const sqlite_database_schema_1 = require("./schema_generation/sqlite_database_schema");
+const pg_database_schema_1 = require("./schema_generation/pg_database_schema");
+const snowflake_database_schema_1 = require("./schema_generation/snowflake_database_schema");
 /////////////////////////
 // NOTES
 /////////////////////////
@@ -17,21 +18,40 @@ class DatabaseSetup {
     run(options) {
         return {
             schemas: {
-                sqlite: new sqlite_database_schema_1.SQLiteDatabaseSchema(this.reg).run(),
+                sqlite: this.driver(new sqlite_database_schema_1.SQLiteDatabaseSchema(this.reg)),
                 hdb: ["todo"],
-                pg: new pg_database_schema_1.PGDatabaseSchema(this.reg).run(),
+                pg: this.driver(new pg_database_schema_1.PGDatabaseSchema(this.reg)),
+                snowflake: this.driver(new snowflake_database_schema_1.SnowflakeDatabaseSchema(this.reg)),
             },
             insert: this.buildInsert(options),
         };
     }
     ////////////////////
+    driver(schemaGenerator) {
+        const statements = [];
+        // CREATE TABLEs
+        for (const obj of this.reg.getObjects()) {
+            if (obj instanceof abaplint.Objects.Table
+                && obj.getTableCategory() === abaplint.Objects.TableCategory.Transparent) {
+                statements.push(schemaGenerator.buildTABL(obj).trim());
+            }
+        }
+        // CREATE VIEWs after TABLEs
+        // todo: what if the view is based on another view?
+        for (const obj of this.reg.getObjects()) {
+            if (obj instanceof abaplint.Objects.View) {
+                statements.push(schemaGenerator.buildVIEW(obj).trim());
+            }
+        }
+        return statements;
+    }
     buildInsert(options) {
         // note: avoid hitting maximum statement size by splitting into multiple statements
         const insert = [];
         // INSERT data
         for (const obj of this.reg.getObjects()) {
             if (obj instanceof abaplint.Objects.MessageClass) {
-                insert.push(this.insertT100(obj));
+                insert.push(...this.insertT100(obj));
             }
             else if (obj instanceof abaplint.Objects.Class
                 || obj instanceof abaplint.Objects.Interface) {
@@ -73,11 +93,11 @@ class DatabaseSetup {
         // ignore if T100 is unknown
         const obj = this.reg.getObject("TABL", "T100");
         if (obj === undefined) {
-            return "";
+            return [];
         }
-        let ret = "";
+        const ret = [];
         for (const m of msag.getMessages()) {
-            ret += `INSERT INTO t100 ("sprsl", "arbgb", "msgnr", "text") VALUES ('E', '${msag.getName().padEnd(20, " ")}', '${m.getNumber()}', '${this.escape(m.getMessage().padEnd(73, " "))}');\n`;
+            ret.push(`INSERT INTO "t100" ("sprsl", "arbgb", "msgnr", "text") VALUES ('E', '${msag.getName().padEnd(20, " ")}', '${m.getNumber()}', '${this.escape(m.getMessage().padEnd(73, " "))}');`);
         }
         return ret;
     }

package/build/src/db/schema_generation/database_schema_generator.d.ts

@@ -0,0 +1,5 @@
+import * as abaplint from "@abaplint/core";
+export interface DatabaseSchemaGenerator {
+    buildVIEW(view: abaplint.Objects.View): string;
+    buildTABL(view: abaplint.Objects.Table): string;
+}

package/build/src/db/schema_generation/database_schema_generator.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=database_schema_generator.js.map

package/build/src/db/schema_generation/pg_database_schema.d.ts

@@ -0,0 +1,9 @@
+import * as abaplint from "@abaplint/core";
+import { DatabaseSchemaGenerator } from "./database_schema_generator";
+export declare class PGDatabaseSchema implements DatabaseSchemaGenerator {
+    private readonly reg;
+    constructor(reg: abaplint.IRegistry);
+    buildVIEW(view: abaplint.Objects.View): string;
+    buildTABL(tabl: abaplint.Objects.Table): string;
+    private toType;
+}

package/build/src/db/{pg_database_schema.js → schema_generation/pg_database_schema.js}

@@ -6,26 +6,6 @@ class PGDatabaseSchema {
     constructor(reg) {
         this.reg = reg;
     }
-    run() {
-        const statements = [];
-        // CREATE TABLEs
-        for (const obj of this.reg.getObjects()) {
-            if (obj instanceof abaplint.Objects.Table
-                && obj.getTableCategory() === abaplint.Objects.TableCategory.Transparent) {
-                statements.push(this.buildTABL(obj).trim());
-            }
-        }
-        // CREATE VIEWs after TABLEs
-        // todo: what if the view is based on another view?
-        for (const obj of this.reg.getObjects()) {
-            if (obj instanceof abaplint.Objects.View) {
-                statements.push(this.buildVIEW(obj).trim());
-            }
-        }
-        return statements;
-    }
-    //////////////////
-    // https://www.sqlite.org/lang_createview.html
     buildVIEW(view) {
         const fields = view.getFields();
         let firstTabname = "";

package/build/src/db/schema_generation/snowflake_database_schema.d.ts

@@ -0,0 +1,9 @@
+import * as abaplint from "@abaplint/core";
+import { DatabaseSchemaGenerator } from "./database_schema_generator";
+export declare class SnowflakeDatabaseSchema implements DatabaseSchemaGenerator {
+    private readonly reg;
+    constructor(reg: abaplint.IRegistry);
+    buildVIEW(view: abaplint.Objects.View): string;
+    buildTABL(tabl: abaplint.Objects.Table): string;
+    private toType;
+}

package/build/src/db/schema_generation/snowflake_database_schema.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnowflakeDatabaseSchema = void 0;
+const abaplint = require("@abaplint/core");
+class SnowflakeDatabaseSchema {
+    constructor(reg) {
+        this.reg = reg;
+    }
+    buildVIEW(view) {
+        const fields = view.getFields();
+        let firstTabname = "";
+        const columns = fields === null || fields === void 0 ? void 0 : fields.map((f) => {
+            firstTabname = "'" + f.TABNAME.toLowerCase() + "'";
+            return firstTabname + "." + f.FIELDNAME.toLowerCase() + " AS " + f.VIEWFIELD.toLowerCase();
+        }).join(", ");
+        let from = "";
+        let previous = "";
+        for (const j of view.getJoin() || []) {
+            if (previous === "") {
+                from += "'" + j.LTAB.toLowerCase() + "' INNER JOIN '" + j.RTAB.toLowerCase() + "' ON '" + j.LTAB.toLowerCase() + "'." + j.LFIELD.toLowerCase() + " = '" + j.RTAB.toLowerCase() + "'." + j.RFIELD.toLowerCase();
+            }
+            else if (previous === j.LTAB + "," + j.RTAB) {
+                from += " AND '" + j.LTAB.toLowerCase() + "'." + j.LFIELD.toLowerCase() + " = '" + j.RTAB.toLowerCase() + "'." + j.RFIELD.toLowerCase();
+            }
+            else {
+                from += " INNER JOIN '" + j.RTAB.toLowerCase() + "' ON '" + j.LTAB.toLowerCase() + "'." + j.LFIELD.toLowerCase() + " = '" + j.RTAB.toLowerCase() + "'." + j.RFIELD.toLowerCase();
+            }
+            previous = j.LTAB + "," + j.RTAB;
+        }
+        from = from.trim();
+        if (from === "") {
+            from = firstTabname;
+        }
+        return `CREATE VIEW '${view.getName().toLowerCase()}' AS SELECT ${columns} FROM ${from};\n`;
+    }
+    buildTABL(tabl) {
+        const type = tabl.parseType(this.reg);
+        if (!(type instanceof abaplint.BasicTypes.StructureType)) {
+            return "";
+        }
+        const fields = [];
+        const fieldsRaw = [];
+        for (const field of type.getComponents()) {
+            if (field.type instanceof abaplint.BasicTypes.StructureType) {
+                // is a GROUP NAME
+                continue;
+            }
+            fieldsRaw.push(field.name.toLowerCase());
+            fields.push("\"" + field.name.toLowerCase() + "\" " + this.toType(field.type, field.name, tabl.getName()));
+        }
+        // assumption: all transparent tables have primary keys
+        // add single quotes to field names to allow for keywords as field names
+        const key = ", PRIMARY KEY(" + tabl.listKeys(this.reg)
+            .filter(e => fieldsRaw.includes(e.toLowerCase()))
+            .map(e => "\"" + e.toLowerCase() + "\"").join(",") + ")";
+        return `CREATE TABLE "${tabl.getName().toLowerCase()}" (${fields.join(", ")}${key});\n`;
+    }
+    // https://docs.snowflake.com/en/sql-reference/collation
+    toType(type, fieldname, errorInfo) {
+        if (type instanceof abaplint.BasicTypes.CharacterType) {
+            return `NCHAR(${type.getLength()}) COLLATE 'rtrim'`;
+        }
+        else if (type instanceof abaplint.BasicTypes.TimeType) {
+            return `NCHAR(6)`;
+        }
+        else if (type instanceof abaplint.BasicTypes.DateType) {
+            return `NCHAR(8)`;
+        }
+        else if (type instanceof abaplint.BasicTypes.NumericType) {
+            // it will be fine, the runtime representation of numc is also text
+            return `NCHAR(${type.getLength()})`;
+        }
+        else if (type instanceof abaplint.BasicTypes.StringType) {
+            return `TEXT`;
+        }
+        else if (type instanceof abaplint.BasicTypes.XStringType) {
+            // it will be fine, the runtime representation of xstring is also text
+            return `TEXT`;
+        }
+        else if (type instanceof abaplint.BasicTypes.HexType) {
+            return `NCHAR(${type.getLength() * 2})`;
+        }
+        else if (type instanceof abaplint.BasicTypes.IntegerType) {
+            return `INT`;
+        }
+        else if (type instanceof abaplint.BasicTypes.FloatType
+            || type instanceof abaplint.BasicTypes.FloatingPointType) {
+            return `REAL`;
+        }
+        else if (type instanceof abaplint.BasicTypes.PackedType) {
+            return `DECIMAL(${type.getLength()},${type.getDecimals()})`;
+        }
+        else if (type instanceof abaplint.BasicTypes.VoidType) {
+            throw `Type of ${errorInfo}-${fieldname} is VoidType(${type.getVoided()}), make sure the type is known, enable strict syntax checking`;
+        }
+        else {
+            throw "database_setup: " + errorInfo + "-" + fieldname + ", todo toType handle: " + type.constructor.name;
+        }
+    }
+}
+exports.SnowflakeDatabaseSchema = SnowflakeDatabaseSchema;
+//# sourceMappingURL=snowflake_database_schema.js.map

package/build/src/db/schema_generation/sqlite_database_schema.d.ts

@@ -0,0 +1,9 @@
+import * as abaplint from "@abaplint/core";
+import { DatabaseSchemaGenerator } from "./database_schema_generator";
+export declare class SQLiteDatabaseSchema implements DatabaseSchemaGenerator {
+    private readonly reg;
+    constructor(reg: abaplint.IRegistry);
+    buildVIEW(view: abaplint.Objects.View): string;
+    buildTABL(tabl: abaplint.Objects.Table): string;
+    private toType;
+}

package/build/src/db/{sqlite_database_schema.js → schema_generation/sqlite_database_schema.js}

@@ -6,25 +6,6 @@ class SQLiteDatabaseSchema {
     constructor(reg) {
         this.reg = reg;
     }
-    run() {
-        const statements = [];
-        // CREATE TABLEs
-        for (const obj of this.reg.getObjects()) {
-            if (obj instanceof abaplint.Objects.Table
-                && obj.getTableCategory() === abaplint.Objects.TableCategory.Transparent) {
-                statements.push(this.buildTABL(obj).trim());
-            }
-        }
-        // CREATE VIEWs after TABLEs
-        // todo: what if the view is based on another view?
-        for (const obj of this.reg.getObjects()) {
-            if (obj instanceof abaplint.Objects.View) {
-                statements.push(this.buildVIEW(obj).trim());
-            }
-        }
-        return statements;
-    }
-    //////////////////
     // https://www.sqlite.org/lang_createview.html
     buildVIEW(view) {
         const fields = view.getFields();

package/build/src/expressions/sql_field_name.js

@@ -6,9 +6,14 @@ class SQLFieldNameTranspiler {
     transpile(node, _traversal) {
         const chunk = new chunk_1.Chunk();
         let concat = node.concatTokens();
+        /*
         if (concat.includes("~") && concat.split("~")[0].includes("/")) {
-            concat = "'" + concat.replace("~", "'~");
-        }
+          concat = "'" + concat.replace("~", "'~");
+        } else {
+          */
+        concat = concat.replace(/~/, `\\".\\"`);
+        concat = `\\"` + concat + `\\"`;
+        //    }
         chunk.appendString(concat);
         return chunk;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/transpiler",
-  "version": "2.7.88",
+  "version": "2.7.90",
   "description": "Transpiler",
   "main": "build/src/index.js",
   "typings": "build/src/index.d.ts",

package/build/src/db/pg_database_schema.d.ts

@@ -1,9 +0,0 @@
-import * as abaplint from "@abaplint/core";
-export declare class PGDatabaseSchema {
-    private readonly reg;
-    constructor(reg: abaplint.IRegistry);
-    run(): string[];
-    private buildVIEW;
-    private buildTABL;
-    private toType;
-}

package/build/src/db/sqlite_database_schema.d.ts

@@ -1,9 +0,0 @@
-import * as abaplint from "@abaplint/core";
-export declare class SQLiteDatabaseSchema {
-    private readonly reg;
-    constructor(reg: abaplint.IRegistry);
-    run(): string[];
-    private buildVIEW;
-    private buildTABL;
-    private toType;
-}