monetdb 2.0.2 → 2.2.0

package/dist/mapi.js

@@ -272,14 +272,18 @@ function parseTupleLine(line, types) {
 }
 class Response {
     constructor(opt = {}) {
-        this.buff = buffer_1.Buffer.allocUnsafe(MAPI_BLOCK_SIZE).fill(0);
+        this.chunks = [];
+        //this.buff = Buffer.allocUnsafe(MAPI_BLOCK_SIZE).fill(0);
         this.offset = 0;
         this.parseOffset = 0;
-        this.segments = [];
         this.settled = false;
+        this.last = false;
+        this.headerEmitted = false;
         this.stream = opt.stream;
         this.callbacks = opt.callbacks;
         this.fileHandler = opt.fileHandler;
+        this.leftOver = 0;
+        this._str = "";
         if (opt.stream) {
             this.queryStream = new QueryStream();
             if (opt.callbacks && opt.callbacks.resolve)
@@ -287,103 +291,89 @@ class Response {
         }
     }
     append(data) {
-        let srcStartIndx = 0;
-        let srcEndIndx = srcStartIndx + data.length;
-        const l = this.segments.length;
-        let segment = (l > 0 && this.segments[l - 1]) || undefined;
-        let bytesCopied = 0;
+        //let srcStartIndx = 0;
+        //let srcEndIndx = srcStartIndx + data.length;
         let bytesProcessed = 0;
-        if (!this.complete()) {
-            // check if out of space
-            if (this.buff.length - this.offset < data.length) {
-                const bytes = this.expand(MAPI_BLOCK_SIZE);
-                console.log(`expanding by ${bytes} bytes!`);
-            }
-            if (segment === undefined || (segment && segment.isFull())) {
-                const hdr = data.readUInt16LE(0);
-                const last = (hdr & 1) === 1;
-                const bytes = hdr >> 1;
-                srcStartIndx = MAPI_HEADER_SIZE;
-                srcEndIndx = srcStartIndx + Math.min(bytes, data.length);
-                bytesCopied = data.copy(this.buff, this.offset, srcStartIndx, srcEndIndx);
-                segment = new Segment(bytes, last, this.offset, bytesCopied);
-                this.segments.push(segment);
-                this.offset += bytesCopied;
-                bytesProcessed = MAPI_HEADER_SIZE + bytesCopied;
-            }
-            else {
-                const byteCntToRead = segment.bytes - segment.bytesOffset;
-                srcEndIndx = srcStartIndx + byteCntToRead;
-                bytesCopied = data.copy(this.buff, this.offset, srcStartIndx, srcEndIndx);
-                this.offset += bytesCopied;
-                segment.bytesOffset += bytesCopied;
-                // console.log(`segment is full ${segment.bytesOffset === segment.bytes}`);
-                bytesProcessed = bytesCopied;
-            }
-            if (this.isQueryResponse()) {
-                const tuples = [];
-                const firstPackage = this.parseOffset === 0;
-                this.parseOffset += this.parse(this.toString(this.parseOffset), tuples);
-                if (tuples.length > 0) {
-                    if (this.queryStream) {
-                        // emit header once
-                        if (firstPackage && this.result && this.result.columns) {
-                            this.queryStream.emit("header", this.result.columns);
-                        }
-                        // emit tuples
-                        this.queryStream.emit("data", tuples);
-                    }
-                    else {
-                        this.result.data = this.result.data || [];
-                        for (let t of tuples) {
-                            this.result.data.push(t);
-                        }
-                    }
-                }
-            }
+        if (this.leftOver == 0) {
+            // new mapi blk, read header
+            const hdr = data.readUInt16LE(0);
+            this.last = (hdr & 1) === 1;
+            this.leftOver = hdr >> 1;
+            data = data.subarray(MAPI_HEADER_SIZE);
+            bytesProcessed += MAPI_HEADER_SIZE;
+            //bytesCopied = data.copy(
+            //    this.buff,
+            //    this.offset,
+            //    srcStartIndx,
+            //    srcEndIndx
+            //);
+            //segment = new Segment(bytes, last, this.offset, bytesCopied);
+            //this.segments.push(segment);
+            //this.offset += bytesCopied;
+            //bytesProcessed = MAPI_HEADER_SIZE + bytesCopied;
         }
+        //else {
+        //    const byteCntToRead = segment.bytes - segment.bytesOffset;
+        //    srcEndIndx = srcStartIndx + byteCntToRead;
+        //    bytesCopied = data.copy(
+        //        this.buff,
+        //        this.offset,
+        //        srcStartIndx,
+        //        srcEndIndx
+        //    );
+        //    this.offset += bytesCopied;
+        //    segment.bytesOffset += bytesCopied;
+        //    // console.log(`segment is full ${segment.bytesOffset === segment.bytes}`);
+        //    bytesProcessed = bytesCopied;
+        //}
+        const bytesToRead = Math.min(data.length, this.leftOver);
+        //console.log(`bytesToRead ${bytesToRead}`);
+        if (bytesToRead > 0) {
+            const chunk = data.subarray(0, bytesToRead);
+            this.chunks.push(chunk);
+            this.leftOver -= bytesToRead;
+            bytesProcessed += bytesToRead;
+        }
+        //if (this.isQueryResponse()) {
+        //    const tuples = [];
+        //    // const firstPackage = this.parseOffset === 0;
+        //    this.parseOffset += this.parseQueryResponse(
+        //        this.toString(this.parseOffset),
+        //        tuples
+        //    );
+        //    console.log("tuples");
+        //    console.log(tuples);
+        //    if (tuples.length > 0) {
+        //        if (this.queryStream) {
+        //            // emit header once
+        //            if (
+        //                this.headerEmitted === false &&
+        //                this.result &&
+        //                this.result.columns
+        //            ) {
+        //                this.queryStream.emit("header", this.result.columns);
+        //                this.headerEmitted = true;
+        //            }
+        //            // emit tuples
+        //            this.queryStream.emit("data", tuples);
+        //        } else {
+        //            this.result.data = this.result.data || [];
+        //            for (let t of tuples) {
+        //                this.result.data.push(t);
+        //            }
+        //        }
+        //    }
+        //}
+        //console.log(`bytesProcessed ${bytesToRead}`);
         return bytesProcessed;
     }
     complete() {
-        const l = this.segments.length;
-        if (l > 0) {
-            const segment = this.segments[l - 1];
-            return segment.last && segment.isFull();
-        }
-        return false;
-    }
-    seekOffset() {
-        const len = this.segments.length;
-        if (len) {
-            const last = this.segments[len - 1];
-            if (last.isFull())
-                return last.offset + last.bytes;
-            return last.offset;
-        }
-        return 0;
-    }
-    expand(byteCount) {
-        if (this.buff.length + byteCount > MAX_BUFF_SIZE &&
-            this.fileHandler instanceof file_transfer_1.FileDownloader) {
-            const offset = this.seekOffset();
-            if (offset) {
-                this.fileHandler.writeChunk(this.buff.subarray(0, offset));
-                this.buff = this.buff.subarray(offset);
-                this.offset -= offset;
-            }
-        }
-        const buff = buffer_1.Buffer.allocUnsafe(this.buff.length + byteCount).fill(0);
-        const bytesCopied = this.buff.copy(buff);
-        this.buff = buff;
-        // should be byteCount
-        return this.buff.length - bytesCopied;
-    }
-    firstCharacter() {
-        return this.buff.toString("utf8", 0, 1);
+        return this.last && (this.leftOver == 0);
     }
     errorMessage() {
-        if (this.firstCharacter() === MSG_ERROR) {
-            return this.buff.toString("utf8", 1);
+        const msg = this.toString();
+        if (msg.startsWith(MSG_ERROR)) {
+            return msg;
         }
         return "";
     }
@@ -391,27 +381,32 @@ class Response {
         return this.toString().startsWith(MSG_FILETRANS);
     }
     isPrompt() {
-        // perhaps use toString
-        return this.complete() && this.firstCharacter() === "\x00";
+        return this.complete() && this.toString() == MSG_PROMPT;
     }
     isRedirect() {
-        return this.firstCharacter() === MSG_REDIRECT;
+        return this.toString().startsWith(MSG_REDIRECT);
     }
     isQueryResponse() {
         if (this.result && this.result.type) {
             return this.result.type.startsWith(MSG_Q);
         }
-        return this.firstCharacter() === MSG_Q;
+        return this.toString().startsWith(MSG_Q);
     }
     isMsgMore() {
         // server wants more ?
         return this.toString().startsWith(MSG_MORE);
     }
     toString(start) {
-        const res = this.buff.toString("utf8", 0, this.offset);
+        if (this.complete() && !this.queryStream && this._str) {
+            if (start)
+                return this._str.substring(start);
+            return this._str;
+        }
+        const buff = buffer_1.Buffer.concat(this.chunks);
+        this._str = buff.toString("utf8");
         if (start)
-            return res.substring(start);
-        return res;
+            return this._str.substring(start);
+        return this._str;
     }
     settle(res) {
         if (this.settled === false && this.complete()) {
@@ -439,116 +434,113 @@ class Response {
                 }
             }
             this.settled = true;
+            this._str = "";
+            this.chunks = [];
         }
     }
-    parse(data, res) {
+    parseQueryResponse(data, res) {
         let offset = 0;
-        const lines = data.split("\n").length;
-        if (this.isQueryResponse()) {
-            let eol = data.indexOf("\n");
-            this.result = this.result || {};
-            if (this.result.type === undefined &&
-                data.startsWith(MSG_Q) &&
-                lines > 0) {
-                // process 1st line
-                const line = data.substring(0, eol);
-                this.result.type = line.substring(0, 2);
-                const rest = line.substring(3).trim().split(" ");
-                if (this.result.type === MSG_QTABLE) {
-                    const [id, rowCnt, columnCnt, rows, queryId, queryTime, malOptimizerTime, sqlOptimizerTime,] = rest;
-                    this.result.id = parseInt(id);
-                    this.result.rowCnt = parseInt(rowCnt);
-                    this.result.columnCnt = parseInt(columnCnt);
-                    this.result.queryId = parseInt(queryId);
-                    this.result.queryTime = parseInt(queryTime);
-                    this.result.malOptimizerTime = parseInt(malOptimizerTime);
-                    this.result.sqlOptimizerTime = parseInt(sqlOptimizerTime);
-                }
-                else if (this.result.type === MSG_QUPDATE) {
-                    const [affectedRowCnt, autoIncrementId, queryId, queryTime, malOptimizerTime, sqlOptimizerTime,] = rest;
-                    this.result.affectedRows = parseInt(affectedRowCnt);
-                    this.result.queryId = parseInt(queryId);
-                    this.result.queryTime = parseInt(queryTime);
-                    this.result.malOptimizerTime = parseInt(malOptimizerTime);
-                    this.result.sqlOptimizerTime = parseInt(sqlOptimizerTime);
-                }
-                else if (this.result.type === MSG_QSCHEMA) {
-                    const [queryTime, malOptimizerTime] = rest;
-                    this.result.queryTime = parseInt(queryTime);
-                    this.result.malOptimizerTime = parseInt(malOptimizerTime);
-                }
-                else if (this.result.type === MSG_QTRANS) {
-                    // skip
-                }
-                else if (this.result.type === MSG_QPREPARE) {
-                    const [id, rowCnt, columnCnt, rows] = rest;
-                    this.result.id = parseInt(id);
-                    this.result.rowCnt = parseInt(rowCnt);
-                    this.result.columnCnt = parseInt(columnCnt);
-                }
-                // end 1st line
-                if (this.headers === undefined &&
-                    data.charAt(eol + 1) === MSG_HEADER &&
-                    lines > 5) {
-                    let headers = {};
-                    while (data.charAt(eol + 1) === MSG_HEADER) {
-                        const hs = eol + 1;
-                        eol = data.indexOf("\n", hs);
-                        headers = Object.assign(Object.assign({}, headers), parseHeaderLine(data.substring(hs, eol)));
+        let eol = data.indexOf("\n");
+        let line = eol > 0 ? data.substring(0, eol) : undefined;
+        while (line) {
+            switch (line.charAt(0)) {
+                case MSG_Q:
+                    // first line
+                    this.result = this.result || {};
+                    this.result.type = line.substring(0, 2);
+                    const rest = line.substring(3).trim().split(" ");
+                    if (this.result.type === MSG_QTABLE) {
+                        const [id, rowCnt, columnCnt, rows, queryId, queryTime, malOptimizerTime, sqlOptimizerTime,] = rest;
+                        this.result.id = parseInt(id);
+                        this.result.rowCnt = parseInt(rowCnt);
+                        this.result.columnCnt = parseInt(columnCnt);
+                        this.result.queryId = parseInt(queryId);
+                        this.result.queryTime = parseInt(queryTime);
+                        this.result.malOptimizerTime = parseInt(malOptimizerTime);
+                        this.result.sqlOptimizerTime = parseInt(sqlOptimizerTime);
                     }
-                    this.headers = headers;
-                    const colums = [];
-                    for (let i = 0; i < this.result.columnCnt; i++) {
-                        const table = headers.tableNames && headers.tableNames[i];
-                        const name = headers.columnNames && headers.columnNames[i];
-                        const type = headers.columnTypes && headers.columnTypes[i];
-                        colums.push({
-                            table,
-                            name,
-                            type,
-                            index: i,
-                        });
+                    else if (this.result.type === MSG_QUPDATE) {
+                        const [affectedRowCnt, autoIncrementId, queryId, queryTime, malOptimizerTime, sqlOptimizerTime,] = rest;
+                        this.result.affectedRows = parseInt(affectedRowCnt);
+                        this.result.queryId = parseInt(queryId);
+                        this.result.queryTime = parseInt(queryTime);
+                        this.result.malOptimizerTime = parseInt(malOptimizerTime);
+                        this.result.sqlOptimizerTime = parseInt(sqlOptimizerTime);
                     }
-                    this.result.columns = colums;
-                }
-            }
-            offset = eol + 1;
-            let ts = undefined; // tuple index
-            if (data.startsWith(MSG_TUPLE)) {
-                ts = 0;
-            }
-            else if (data.charAt(eol + 1) === MSG_TUPLE) {
-                ts = eol + 1;
-                eol = data.indexOf("\n", ts);
-            }
-            if (ts !== undefined && eol > 0) {
-                // we have a data row
-                do {
-                    offset = eol + 1;
-                    const tuple = parseTupleLine(data.substring(ts, eol), this.headers.columnTypes);
-                    res.push(tuple);
-                    if (data.charAt(eol + 1) === MSG_TUPLE) {
-                        ts = eol + 1;
-                        eol = data.indexOf("\n", ts);
+                    else if (this.result.type === MSG_QSCHEMA) {
+                        const [queryTime, malOptimizerTime] = rest;
+                        this.result.queryTime = parseInt(queryTime);
+                        this.result.malOptimizerTime = parseInt(malOptimizerTime);
+                    }
+                    else if (this.result.type === MSG_QTRANS) {
+                        // skip
+                    }
+                    else if (this.result.type === MSG_QPREPARE) {
+                        const [id, rowCnt, columnCnt, rows] = rest;
+                        this.result.id = parseInt(id);
+                        this.result.rowCnt = parseInt(rowCnt);
+                        this.result.columnCnt = parseInt(columnCnt);
+                    }
+                    break;
+                case MSG_HEADER:
+                    const header = parseHeaderLine(line);
+                    if (this.result.headers !== undefined) {
+                        this.result.headers = Object.assign(Object.assign({}, this.result.headers), header);
                     }
                     else {
-                        ts = undefined;
+                        this.result.headers = header;
+                    }
+                    // if we have all headers we can compile column info
+                    const haveAllHeaders = Boolean(this.result.headers.tableNames) &&
+                        Boolean(this.result.headers.columnNames) &&
+                        Boolean(this.result.headers.columnTypes);
+                    if (this.result.columns === undefined && haveAllHeaders) {
+                        const colums = [];
+                        for (let i = 0; i < this.result.columnCnt; i++) {
+                            const table = this.result.headers.tableNames[i];
+                            const name = this.result.headers.columnNames[i];
+                            const type = this.result.headers.columnTypes[i];
+                            colums.push({
+                                table,
+                                name,
+                                type,
+                                index: i,
+                            });
+                        }
+                        this.result.columns = colums;
                     }
-                } while (ts && eol > -1);
+                    break;
+                case MSG_TUPLE:
+                    const tuple = parseTupleLine(line, this.result.headers.columnTypes);
+                    res.push(tuple);
+                    break;
+                default:
+                    throw TypeError(`Invalid query response line!\n${line}`);
             }
+            // line is processed advance offset
+            offset = eol + 1;
+            // get next line
+            eol = data.indexOf("\n", offset);
+            line = eol > 0 ? data.substring(offset, eol) : undefined;
         }
         return offset;
     }
-}
-class Segment {
-    constructor(bytes, last, offset, bytesOffset) {
-        this.bytes = bytes;
-        this.last = last;
-        this.offset = offset;
-        this.bytesOffset = bytesOffset;
-    }
-    isFull() {
-        return this.bytes === this.bytesOffset;
+    streamResult() {
+        if (this.queryStream && this.isQueryResponse()) {
+            const tuples = [];
+            this.parseOffset += this.parseQueryResponse(this.toString(this.parseOffset), tuples);
+            if (tuples.length > 0) {
+                // emit header once
+                if (this.headerEmitted === false &&
+                    this.result &&
+                    this.result.columns) {
+                    this.queryStream.emit("header", this.result.columns);
+                    this.headerEmitted = true;
+                }
+                // emit tuples
+                this.queryStream.emit("data", tuples);
+            }
+        }
     }
 }
 class MapiConnection extends events_1.EventEmitter {
@@ -561,23 +553,12 @@ class MapiConnection extends events_1.EventEmitter {
             socket.addListener("data", this.recv.bind(this));
             socket.addListener("error", this.handleSocketError.bind(this));
             socket.addListener("timeout", this.handleTimeout.bind(this));
-            socket.addListener("close", () => {
-                console.log("socket close event");
-                this.emit("end");
+            socket.once("end", () => {
+                console.log("Server has ended the connection");
             });
             return socket;
         };
         this.state = MAPI_STATE.INIT;
-        this.socket = this.createSocket(config.timeout);
-        // this.socket = new Socket();
-        // if (config.timeout) this.socket.setTimeout(config.timeout);
-        // this.socket.addListener("data", this.recv.bind(this));
-        // this.socket.addListener("error", this.handleSocketError.bind(this));
-        // this.socket.addListener("timeout", this.handleTimeout.bind(this));
-        // this.socket.addListener("close", () => {
-        //   console.log("socket close event");
-        //   this.emit("end");
-        // });
         this.redirects = 0;
         this.queue = [];
         this.database = config.database;
@@ -608,18 +589,46 @@ class MapiConnection extends events_1.EventEmitter {
         return (0, events_1.once)(this, "ready");
     }
     ready() {
-        return this.state === MAPI_STATE.READY;
+        return this.socket && this.socket.writable && this.state === MAPI_STATE.READY;
     }
     disconnect() {
         return new Promise((resolve, reject) => {
-            this.socket.end(() => {
-                this.redirects = 0;
+            if (!this.socket || this.socket.destroyed) {
+                this.socket = null;
                 this.state = MAPI_STATE.INIT;
-                this.socket.destroy();
-                resolve(this.state === MAPI_STATE.INIT);
-            });
+                return resolve(true);
+            }
+            const onClose = () => {
+                cleanup();
+                this.socket = null;
+                this.state = MAPI_STATE.INIT;
+                resolve(true);
+            };
+            const onError = (err) => {
+                var _a;
+                console.error(err);
+                cleanup();
+                (_a = this.socket) === null || _a === void 0 ? void 0 : _a.destroy(); // force cleanup
+                this.socket = null;
+                this.state = MAPI_STATE.INIT;
+                reject(err);
+            };
+            const cleanup = () => {
+                var _a, _b;
+                (_a = this.socket) === null || _a === void 0 ? void 0 : _a.removeListener("close", onClose);
+                (_b = this.socket) === null || _b === void 0 ? void 0 : _b.removeListener("error", onError);
+            };
+            this.socket.once("close", onClose);
+            this.socket.once("error", onError);
+            // Initiate graceful shutdown
+            this.socket.end();
         });
     }
+    destroy() {
+        if (this.socket && !this.socket.destroyed)
+            this.socket.destroy();
+        this.socket = null;
+    }
     login(challenge) {
         const challengeParts = challenge.split(":");
         const [salt, identity, protocol, hashes, endian, algo, opt_level] = challengeParts;
@@ -718,7 +727,8 @@ class MapiConnection extends events_1.EventEmitter {
         this.emit("error", new Error("Timeout"));
     }
     handleSocketError(err) {
-        console.error(err);
+        console.error('Socket error: ', err);
+        this.destroy();
     }
     request(sql, stream = false) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -751,8 +761,9 @@ class MapiConnection extends events_1.EventEmitter {
     recv(data) {
         let bytesLeftOver;
         let resp;
-        // process queue left to right, find 1st uncomplete response
-        // remove responses that are completed
+        // process queue left to right,
+        // find 1st uncomplete response
+        // remove complete responses
         while (this.queue.length) {
             const next = this.queue[0];
             if (next.complete() || next.settled) {
@@ -766,17 +777,23 @@ class MapiConnection extends events_1.EventEmitter {
         if (resp === undefined && this.queue.length === 0) {
             // challenge message
             // or direct call to send has being made
-            // e.g. request api appends Response to the queue
+            // request api appends Response to the queue
             resp = new Response();
             this.queue.push(resp);
         }
-        const offset = resp.append(data);
+        let offset = 0;
+        let end = data.length;
+        do {
+            offset += resp.append(data.subarray(offset, end));
+        } while ((offset < end) && !resp.complete());
+        if (resp.queryStream)
+            resp.streamResult();
         if (resp.complete())
             this.handleResponse(resp);
         bytesLeftOver = data.length - offset;
         if (bytesLeftOver) {
-            const msg = `some ${bytesLeftOver} bytes left over!`;
-            console.warn(msg);
+            //const msg = `some ${bytesLeftOver} bytes left over!`;
+            //console.warn(msg);
             this.recv(data.subarray(offset));
         }
     }
@@ -794,7 +811,7 @@ class MapiConnection extends events_1.EventEmitter {
                 return;
             }
             if (resp.isPrompt()) {
-                console.log("login OK");
+                //console.log("login OK");
                 this.state = MAPI_STATE.READY;
                 this.emit("ready", this.state);
                 return;
@@ -802,7 +819,7 @@ class MapiConnection extends events_1.EventEmitter {
             return this.login(resp.toString());
         }
         if (resp.isFileTransfer()) {
-            console.log("file transfer");
+            //console.log("file transfer");
             let fhandler;
             const msg = resp.toString(MSG_FILETRANS.length).trim();
             let mode, offset, file;
@@ -839,11 +856,17 @@ class MapiConnection extends events_1.EventEmitter {
             resp.fileHandler.ready()) {
             // end of download
             const fileHandler = resp.fileHandler;
-            fileHandler.writeChunk(resp.buff);
+            const buff = buffer_1.Buffer.concat(resp.chunks);
+            fileHandler.writeChunk(buff);
             // we do expect a final response from server
             this.queue.push(new Response({ fileHandler }));
             return resp.settle(fileHandler.close());
         }
+        if (resp.isQueryResponse()) {
+            const data = [];
+            resp.parseQueryResponse(resp.toString(), data);
+            resp.result.data = data;
+        }
         resp.settle();
     }
 }