monetdb 1.3.4 → 2.0.0

package/src/monetize.ts

@@ -0,0 +1,67 @@
+function monetEscape(v: any): string {
+    let s = String(v).replace("\\", "\\\\");
+    s = s.replace("\'", "\\\'");
+    return `'${s}'`;
+}
+
+function monetDecimal(v: number, digits?: number, scale?: number): string {
+    if (digits && scale)
+        return `cast(${monetEscape(v)} as decimal(${digits}, ${scale}))`;
+    return `cast(${monetEscape(v)} as decimal)`;
+}
+
+
+function monetDate(v: string): string {
+    return `DATE${monetEscape(v)}`;
+}
+
+
+function monetTime(v: string): string {
+    return `TIME${monetEscape(v)}`;
+}
+
+
+function monetTimestamp(v: string): string {
+    return `TIMESTAMP${monetEscape(v)}`;
+}
+
+
+function monetTimestampZone(v: string): string {
+    return `TIMESTAMPZ${monetEscape(v)}`;
+}
+
+
+function monetUUID(v: string): string {
+    return `UUID${monetEscape(v)}`;
+}
+
+
+function convert(type: string, v: any, digits?: number, scale?: number): any {
+    switch(type) {
+        case "smallint":
+        case "int":
+        case "bigint":
+        case "hugeint":
+        case "double":
+        case "float":
+            return Number(v);
+        case "decimal":
+            return monetDecimal(v, digits, scale);
+        case "boolean":
+            return Boolean(v);
+        case "date":
+            return monetDate(v);
+        case "time":
+            return monetTime(v);
+        case "timestamp":
+            return monetTimestamp(v);
+        case "timestampz":
+            return monetTimestampZone(v);
+        case "uuid":
+            return monetUUID(v);
+        default:
+            return monetEscape(v);
+    }
+}
+
+export {convert}

package/test/connection.ts

@@ -0,0 +1,43 @@
+import assert from "assert";
+import Connection from "../src/connection";
+
+describe("Connection", function () {
+  let conn: Connection;
+
+  it("should connect with default opt", async function () {
+    conn = new Connection({ database: "test" });
+    const ready = await conn.connect();
+    assert(ready, new Error("failed to connect"));
+    const closed = await conn.close();
+    assert(closed);
+  });
+
+  it("should build Connection from mapi uri default username and password", function () {
+    conn = new Connection("mapi:monetdb://foo.com:55555/test");
+    assert.strictEqual(conn.mapi.host, "foo.com");
+    assert.strictEqual(conn.mapi.port, 55555);
+    assert.strictEqual(conn.mapi.username, "monetdb");
+    assert.strictEqual(conn.mapi.password, "monetdb");
+    assert.strictEqual(conn.mapi.database, "test");
+  });
+
+  it("should build Connection from mapi uri with auth component", function () {
+    conn = new Connection(
+      "mapi:monetdb://barname:barpassword@foo.com:55555/test"
+    );
+    assert.strictEqual(conn.mapi.host, "foo.com");
+    assert.strictEqual(conn.mapi.port, 55555);
+    assert.strictEqual(conn.mapi.username, "barname");
+    assert.strictEqual(conn.mapi.password, "barpassword");
+    assert.strictEqual(conn.mapi.database, "test");
+  });
+
+  it("should build Connection from mapi uri no port", function () {
+    conn = new Connection("mapi:monetdb://foo.com/test");
+    assert.strictEqual(conn.mapi.host, "foo.com");
+    assert.strictEqual(conn.mapi.port, 50000);
+    assert.strictEqual(conn.mapi.username, "monetdb");
+    assert.strictEqual(conn.mapi.password, "monetdb");
+    assert.strictEqual(conn.mapi.database, "test");
+  });
+});

package/test/exec-queries.ts

@@ -0,0 +1,100 @@
+import assert from "assert";
+import Connection from "../src/connection";
+
+describe("Exec queres", function () {
+  let conn: Connection;
+  beforeEach(function () {
+    conn = new Connection({ database: "test" });
+  });
+
+  afterEach(async function () {
+    const closed = await conn.close();
+    assert(closed);
+  });
+
+  it("should handle single select query", async function () {
+    const ready = await conn.connect();
+    assert(ready, new Error("failed to connect"));
+    const res = await conn.execute("select * from generate_series(1, 10)");
+    assert.equal(res.rowCnt, 9);
+    assert.equal(res.data.length, 9);
+  });
+
+  it("should handle many queres", async function () {
+    const ready = await conn.connect();
+    assert(ready, new Error("failed to connect"));
+    const [res1, res2, res3] = await Promise.all([
+      conn.execute("select * from generate_series(1, 11)"),
+      conn.execute("select * from generate_series(11, 21)"),
+      conn.execute("select * from generate_series(21, 31)"),
+    ]);
+    assert.deepStrictEqual(res1.data, [
+      [1],
+      [2],
+      [3],
+      [4],
+      [5],
+      [6],
+      [7],
+      [8],
+      [9],
+      [10],
+    ]);
+    assert.deepStrictEqual(res2.data, [
+      [11],
+      [12],
+      [13],
+      [14],
+      [15],
+      [16],
+      [17],
+      [18],
+      [19],
+      [20],
+    ]);
+    assert.deepStrictEqual(res3.data, [
+      [21],
+      [22],
+      [23],
+      [24],
+      [25],
+      [26],
+      [27],
+      [28],
+      [29],
+      [30],
+    ]);
+  });
+
+  it("should handle insert statements", async function () {
+    const ready = await conn.connect();
+    assert(ready, new Error("failed to connect"));
+    let res = await conn.execute("create schema test");
+    res = await conn.execute("create table foo(a string)");
+    res = await conn.execute("insert into foo values ('foo'), ('bar')");
+    res = await conn.execute("select * from foo");
+    assert.deepStrictEqual(res.data, [["foo"], ["bar"]]);
+  });
+
+  it("should rollback", async function () {
+    const ready = await conn.connect();
+    assert(ready, new Error("failed to connect"));
+    let res = await conn.execute("create table foo(a string)");
+    res = await conn.execute("select name from tables where name='foo'");
+    assert.strictEqual(res.rowCnt, 1);
+    res = await conn.rollback();
+    res = await conn.execute("select name from tables where name='foo'");
+    assert.strictEqual(res.rowCnt, 0);
+  });
+
+  it("should handle 2 byte characters exceeding mapi block", async () => {
+    let s = "éééééééééééééééééééééééééééé";
+    let string = "";
+    for (let i = 0; i < 1000; i++) string += s;
+    const qry = `select \'${string}\'`;
+    const ready = await conn.connect();
+    assert(ready, new Error("failed to connect"));
+    const res = await conn.execute(qry);
+    assert.strictEqual(res.rowCnt, 1);
+  });
+});

package/test/filetransfer.ts

@@ -0,0 +1,94 @@
+import assert from 'assert';
+import Connection from '../src/connection';
+import fs from 'node:fs/promises';
+
+describe('File Transfer', function() {
+    let conn: Connection;
+    let fooFile = 'test/tmp/foo'
+    beforeEach(function() {
+        conn = new Connection({database: 'test'});
+    });
+
+    afterEach(async function() {
+        const closed = await conn.close();
+        assert(closed);
+    });
+
+    it('should upload binary file', async function() {
+        const ready = await conn.connect();
+        assert(ready, new Error('failed to connect'));
+        await conn.execute('create table foo(i int)');
+        const f = await fs.open(fooFile, 'w');
+        const buff = Buffer.alloc(12);
+        buff.writeInt32LE(1, 0);
+        buff.writeInt32LE(2, 4);
+        buff.writeInt32LE(3, 8);
+        f.write(buff);
+        await f.close();
+        let res = await conn.execute(`copy binary into foo from \'${fooFile}\' on client`);
+        res = await conn.execute('select * from foo');
+        assert.deepStrictEqual(res.data, [[1], [2], [3]]);
+    });
+
+    it('should upload text file', async function() {
+        const ready = await conn.connect();
+        assert(ready, new Error('failed to connect'));
+        await conn.execute('create table foo(i int, a varchar(10))');
+        const f = await fs.open(fooFile, 'w');
+        for (let word of ['1|one', '2|two', '3|three']) {
+            f.write(word + '\n');
+        }
+        await f.close();
+        let res = await conn.execute(`copy into foo from \'${fooFile}\' on client`);
+        res = await conn.execute('select * from foo order by i');
+        assert.deepStrictEqual(res.data, [[1, 'one'], [2, 'two'], [3, 'three']]);
+    });
+
+    it('should cancel upload on fewer rows', async function() {
+        const ready = await conn.connect();
+        assert(ready, new Error('failed to connect'));
+        await conn.execute('create table foo(i int, a varchar(10))');
+        const f = await fs.open(fooFile, 'w');
+        for (let word of ['1|one', '2|two', '3|three', '4|four', '5|five', '6|six']) {
+            f.write(word + '\n');
+        }
+        await f.close();
+        let res = await conn.execute(`copy 3 records into foo from \'${fooFile}\' on client`);
+        res = await conn.execute('select * from foo order by i');
+        assert.deepStrictEqual(res.rowCnt, 3);
+        // TODO for some reason fails on MacOSX
+        //assert.deepStrictEqual(res.data, [[1, 'one'], [2, 'two'], [3, 'three']]);
+    });
+
+    it('should upload text file skip 2', async function() {
+        const ready = await conn.connect();
+        assert(ready, new Error('failed to connect'));
+        await conn.execute('create table foo(i int, a varchar(10))');
+        const f = await fs.open(fooFile, 'w');
+        for (let word of ['1|one', '2|two', '3|three', '4|four', '5|five', '6|six']) {
+            f.write(word + '\n');
+        }
+        await f.close();
+        let res = await conn.execute(`copy offset 3 into foo from \'${fooFile}\' on client`);
+        res = await conn.execute('select * from foo order by i');
+        assert.deepStrictEqual(res.rowCnt, 4);
+        // TODO for some reason fails on MacOSX
+        //assert.deepStrictEqual(res.data, [[3, "three"], [4, "four"], [5, "five"], [6, "six"]]);
+    });
+
+
+    it('should download text file', async function() {
+        const ready = await conn.connect();
+        assert(ready, new Error('failed to connect'));
+        let res = await conn.execute('copy (select * from sys.generate_series(1,1001)) into \'test/tmp/foo\' on client');
+        assert.strictEqual(res.affectedRows, 1000);
+    });
+
+    it('should fail on forbidden path', async function() {
+        const ready = await conn.connect();
+        assert(ready, new Error('failed to connect'));
+        await conn.execute('create table foo(i varchar(10))');
+        await assert.rejects(conn.execute(`copy into foo from \'../../foo\' on client`), Error);
+    });
+
+});

package/test/prepare-statement.ts

@@ -0,0 +1,27 @@
+import assert from 'assert';
+import Connection from '../src/connection';
+
+describe('Prepare Statement', function() {
+    let conn: Connection;
+    beforeEach(function() {
+        conn = new Connection({database: 'test'});
+    });
+
+    afterEach(async function(){
+        const closed = await conn.close();
+        assert(closed);
+    });
+
+    it("should prepare inserts", async function() {
+        const ready = await conn.connect();
+        assert(ready, new Error('failed to connect'));
+        let res = await conn.execute('create table foo(a int, b boolean, c string, d date, f decimal)');
+        const prepStmt = await conn.prepare('insert into foo values (?, ?, ?, ?, ?)');
+        res = await prepStmt.execute(1, true, 'first', '2022-12-12', 1.11);
+        res = await prepStmt.execute(2, false, 'second', '2022-12-12', 2.22);
+        res = await prepStmt.execute(3, true, 'third', '2022-12-12', 3.33);
+        await prepStmt.release();
+        res = await conn.execute('select count(*) from foo');
+        assert.strictEqual(res.data[0][0], 3);
+    });
+});

package/test/query-stream.ts

@@ -0,0 +1,41 @@
+import assert from 'assert';
+import Connection from '../src/connection';
+
+describe('Query Stream', function() {
+    let conn: Connection;
+    beforeEach(function() {
+        conn = new Connection({database: 'test'});
+    });
+
+    afterEach(async function(){
+        const closed = await conn.close();
+        assert(closed);
+    });
+
+    it('should stream response', async function() {
+        const ready = await conn.connect();
+        assert(ready, new Error('failed to connect'));
+        const stream = await conn.execute('select * from generate_series(1, 10000)', true);
+        const colInfo = [];
+        const data = [];
+        return new Promise((resolve, reject) => {
+            stream.on('header', (cols: any[]) => {
+                for (let col of cols)
+                    colInfo.push(col);
+            });
+            stream.on('data', (tuples: any[]) => {
+                for (let t of tuples) {
+                    data.push(t);
+                }
+            });
+            stream.on('error', (err: Error) => {
+                reject(err);
+            })
+            stream.on('end', () => {
+                assert.strictEqual(colInfo.length, 1);
+                assert.strictEqual(data.length, 9999);
+                resolve();
+            });
+        })
+    });
+});

package/test/tmp/.gitignore

@@ -0,0 +1,4 @@
+# Ignore everything in this directory
+*
+# Except this file
+!.gitignore

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": false,
+    "target": "es6",
+    "noImplicitAny": false,
+    "moduleResolution": "node",
+    "sourceMap": true,
+    "pretty": true,
+    "outDir": "dist",
+    "incremental": true,
+    "baseUrl": ".",
+    "declaration": true,
+    "types": [
+      "node",
+      "mocha"
+    ]
+  },
+  "include": [
+    "src/**/*.ts"
+  ]
+}

package/.travis.yml

@@ -1,11 +0,0 @@
-language: node_js
-node_js:
-  - "9"
-sudo: required
-install:
-  - sudo bash test/install-monetdb.sh
-  - npm install
-before_script:
-  - bash test/start-monetdb.sh
-after_success:
-  - npm run coveralls

package/dist/mapi.d.ts

@@ -1,58 +0,0 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-import { Socket } from 'node:net';
-import { EventEmitter } from 'events';
-import { Buffer } from 'buffer';
-declare enum MAPI_STATE {
-    INIT = 1,
-    CONNECTED = 2,
-    READY = 3
-}
-declare enum MAPI_LANGUAGE {
-    SQL = "sql",
-    MAPI = "mapi",
-    CONTROL = "control"
-}
-declare class Store {
-    buff: Buffer;
-    offset: number;
-    segments: Segment[];
-    constructor(size?: number);
-    append(data: Buffer): number;
-    expand(byteCount: number): number;
-    drain(): string;
-    isFull(): boolean;
-    toString(): string;
-}
-declare class Segment {
-    offset: number;
-    bytes: number;
-    bytesOffset: number;
-    last: boolean;
-    constructor(bytes: number, last: boolean, offset: number, bytesOffset: number);
-    isFull(): boolean;
-}
-declare class MAPIConnection extends EventEmitter {
-    state: MAPI_STATE;
-    socket: Socket;
-    timeout?: number;
-    username?: string;
-    password?: string;
-    database?: string;
-    hostname?: string;
-    language: MAPI_LANGUAGE;
-    port?: number;
-    redirects: number;
-    store: Store;
-    constructor();
-    connect(database: string, username?: string, password?: string, hostname?: string, port?: number, timeout?: number, language?: MAPI_LANGUAGE): Promise<any[]>;
-    disconnect(): void;
-    private login;
-    private send;
-    private handleTimeout;
-    private handleSocketError;
-    private recv;
-    private handleResponse;
-}
-export default MAPIConnection;