monetdb 2.0.1 → 2.1.0

package/docs/package.json

@@ -1,22 +0,0 @@
-{
-  "name": "docs",
-  "version": "1.0.0",
-  "description": "",
-  "main": "next.config.js",
-  "scripts": {
-    "start": "next dev",
-    "build": "next build"
-  },
-  "keywords": [],
-  "author": {
-    "name": "Svetlin Stalinov",
-    "email": "svetlin.stalinov@monetdbsolutions.com"
-  },
-  "dependencies": {
-    "next": "^14.0.1",
-    "nextra": "^2.13.2",
-    "nextra-theme-docs": "^2.13.2",
-    "react": "^18.2.0",
-    "react-dom": "^18.2.0"
-  }
-}

package/docs/pages/_app.js

@@ -1,9 +0,0 @@
-import 'nextra-theme-docs/style.css'
-
-export default function Nextra({ Component, pageProps }) {
-  return (
-    <>
-      <Component {...pageProps} />
-    </>
-  )
-}

package/docs/pages/_meta.json

@@ -1,18 +0,0 @@
-{
-  "index": "Getting Started",
-  "filetransfer": "File Transfer",
-  "result": "Query result",
-  "prepstmt": "Prepare Statement",
-  "apis": "API",
-  "versions": {
-      "title": "archive",
-      "type": "menu",
-      "items": {
-          "v0": {
-              "title": "v0",
-              "href": "https://github.com/MonetDB/monetdb-nodejs/blob/master/docs/v0"},
-          "v1": {
-              "title": "v1",
-              "href": "https://github.com/MonetDB/monetdb-nodejs/blob/master/docs/v1"}}
-  }
-}

package/docs/pages/apis/_meta.json

@@ -1,4 +0,0 @@
-{
-    "connection": "Connecting",
-    "result": "QueryResult"
-}

package/docs/pages/apis/connection.mdx

@@ -1,60 +0,0 @@
-## Connecting
-```ts
-const conn = new Connection(config: MapiConfig | string);
-```
-, all the optional fields get default values if not specified.
-### Using configuration options
-```ts
-interface MapiConfig {
-    database: string;
-    username?: string;
-    password?: string;
-    language?: MAPI_LANGUAGE; // sql
-    host?: string;
-    port?: number;
-    timeout?: number;
-    autoCommit?: boolean;
-    replySize?: number;
-}
-
-const defaults = {
-    host: process.env.MAPI_HOST || 'localhost',
-    port: process.env.MAPI_PORT || 50000,
-    username: process.env.MAPI_USER || 'monetdb',
-    password: process.env.MAPI_PASSWORD || 'monetdb',
-    database: process.env.MAPI_DATABASE,
-    autoCommit: false,
-    replySize: -1,
-};
-
-const config: MapiConfig = {
-    ...defaults
-    database: 'test',
-    }
-const conn = new Connection(config);
-```
-### Using URL
-```ts
-const conn = new Connection('mapi:monetdb://<username>:<password>@<hostname>:<port>/<database>');
-```
-### Connection object
-```ts
-declare class Connection extends EventEmitter {
-    autoCommit?: boolean;
-    replySize?: number;
-    sizeHeader?: boolean;
-    mapi: MapiConnection;
-    constructor(params: MapiConfig | MAPI_URI);
-    connect(callback?: ConnectCallback): Promise<boolean>;
-    close(): Promise<boolean>;
-    commit(): Promise<any>;
-    private command;
-    execute(sql: string, stream?: boolean): Promise<QueryResult|QueryStream>;
-    prepare(sql: string): Promise<PrepareStatement>;
-    setAutocommit(v: boolean): Promise<boolean>;
-    setReplySize(v: number): Promise<number>;
-    setSizeHeader(v: boolean): Promise<boolean>;
-    setTimezone(sec: number): Promise<any>;
-    rollback(): Promise<any>;
-}
-```

package/docs/pages/apis/result.mdx

@@ -1,39 +0,0 @@
-## Query Result
-The result object returned from sucessful query execution.
-```ts
-type QueryResult = {
-    id?: number;
-    type?: string;
-    queryId?: number;
-    rowCnt?: number;
-    affectedRows?: number;
-    columnCnt?: number;
-    queryTime?: number;
-    sqlOptimizerTime?: number;
-    malOptimizerTime?: number;
-    columns?: Column[];
-    headers?: ResponseHeaders;
-    data?: any[];
-};
-import { Connection } from 'monetdb';
-const conn = new Connection({database: 'test'});
-const ready = await conn.connect();
-const res: QueryResult = await conn.execute('select 1 as one, 2 as two');
-console.log(res);
-// {
-//   type: '&1',
-//   id: 1,
-//   rowCnt: 1,
-//   columnCnt: 2,
-//   queryId: 37,
-//   queryTime: 311,
-//   malOptimizerTime: 129,
-//   sqlOptimizerTime: 22,
-//   columns: [
-//     { table: '.', name: 'one', type: 'tinyint', index: 0 },
-//     { table: '.', name: 'two', type: 'tinyint', index: 1 }
-//   ],
-//   data: [ [ 1, 2 ] ]
-// }
-
-```

package/docs/pages/filetransfer.mdx

@@ -1,43 +0,0 @@
-## File Transfer
-MonetDB supports the non-standard `COPY INTO` statement to load a CSV-like
-text file into a table or to dump a table into a text file. This statement has an
-optional modifier `ON CLIENT` to indicate that the server should not
-try to open the file on the server side but instead ask the client to open it
-on its behalf.
-
-For example::
-```sql
-	COPY INTO mytable FROM 'data.csv' ON CLIENT
-	USING DELIMITERS ',', E'\n', '"';
-```
-For security reason `monetdb-nodejs` enforces files to be realtive to the current
-working directory of the Node.js process.
-## Skip rows and early cancellation
-MonetDB's `COPY INTO` statement allows you to skip, for example, the first
-line in a file using the modifier `OFFSET 2`, and load `n` records from the file using
-`RECORDS` modifier.
-```sql
-	COPY 100 RECORDS OFFSET 2 INTO mytable FROM 'data.csv' ON CLIENT
-```
-, for detailed documentation on `COPY INTO` statement please vist [MonetDB documentation](https://www.monetdb.org/documentation-Jun2023/user-guide/sql-manual/data-loading/)
-## Example
-Assume `data.csv` with the following content
-```bash
-cat<<EOF>data.csv
-1|one
-2|two
-3|three
-EOF
-```
-, then load that into MonetDB
-```ts
-import {Connection} from 'monetdb';
-
-const conn = new Connection({database: 'test'});
-const ready = await conn.connect();
-await conn.execute('create table foo(i int, a varchar(10))');
-let res = await conn.execute(`copy into foo from \'data.csv\' on client`);
-res = await conn.execute('select * from foo order by i');
-console.log(res.data);
-// [[1, 'one'], [2, 'two'], [3, 'three']]
-```

package/docs/pages/index.mdx

@@ -1,27 +0,0 @@
----
-title: Getting Started
-slug: /
----
-
-## Installation
-
-```bash
-$ npm install monetdb
-```
-
-## Usage
-The simplest way to connect is to use default connection options and pass only the database name.
-
-```js
-import { Connection} from 'monetdb'
-
-const opt = {database: 'test'}
-
-const conn = new Connection(opt)
-const ready = await conn.connect();
-const res = conn.exec('select 42');
-console.log(res.data)
-await conn.close();
-```
-, see [connection api](/apis/connection) for more details.
-

package/docs/pages/prepstmt.mdx

@@ -1,13 +0,0 @@
-## Prepare Statement
-The PREPARE statement compiles an SQL statement into its execution plan on the server. This is useful for statements which need to be executed many times but with different values each time, such as an INSERT or UPDATE or SELECT query.
-```ts
-const ready = await conn.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();
-```
-For more information on prepare statement please visit [MonetDB documentation](https://www.monetdb.org/documentation-Jun2023/user-guide/sql-manual/data-manipulation/prepare-statement/). 
-

package/docs/pages/result.mdx

@@ -1,41 +0,0 @@
-## Query result size
-Query result size can be set with `replySize` `Connection` option. It defines the number of data rows returned in the initial response.
-By default this options is set to `-1`, which means fetch all the data. If `replySize` is set to any positive number, only that many
-data rows will be fetched, while the rest will stay cached at the server. The `replySize` can be set initially when connection is created, or by invoking `setReplySize` method on the `Connection` object.
-```ts
-// set replySize to 100
-const conn = new Connection({database: 'test', replySize: 100});
-await conn.connect();
-let res = await conn.execute("select * from generate_series(1, 1001)");
-console.log(res.data.length);
-// 100
-await conn.setReplySize(-1); // back to default
-res = await conn.execute("select * from generate_series(1, 1001)");
-console.log(res.data.length);
-// 1000
-```
-## Streaming query result
-When query result is quite large it's often useful to start process the data chunks as soon as they are available
-on the client. This can be achieved by invoking `execute` method on the `Connection` object with `stream=true`.
-```ts
-//  execute(sql: string, stream?: boolean): Promise<any>;
-const ready = await conn.connect();
-const stream: QueryStream = await conn.execute('select * from generate_series(1, 10000)', true);
-const colInfo = [];
-const data = [];
-stream.on('header', (cols: any[]) => {
-    // do something with col info
-});
-
-stream.on('data', (tuples: any[]) => {
-    for (let t of tuples) {
-        data.push(t);
-    }
-});
-
-stream.on('end', () => {
-  // do something on end of streaming
-});
-
-await conn.close();
-```

package/docs/theme.config.js

@@ -1,35 +0,0 @@
-// theme.config.js
-export default {
-  project: {
-    link: 'https://github.com/MonetDB/monetdb-nodejs',
-  },
-  docsRepositoryBase: 'https://github.com/MonetDB/monetdb-nodejs/blob/master/docs', // base URL for the docs repository
-  darkMode: true,
-  footer: true,
-  navigation: {
-    prev: true,
-    next: true,
-  },
-  footer: {
-    text: `Mozilla Public License, v.2.0 ${new Date().getFullYear()}`,
-  },
-  editLink: {
-    text: 'Edit this page on GitHub',
-  },
-  logo: (
-    <>
-      <span>monetdb-nodejs</span>
-    </>
-  ),
-  head: (
-    <>
-      <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-      <meta
-        name="description"
-        content="MonetDB Node.js connector"
-      />
-      <meta name="og:title" content="monetdb-nodejs" />
-      <meta name="og:description" content="MonetDB Node.js driver" />
-    </>
-  ),
-}

package/docs/v0/README.v0.md

@@ -1,138 +0,0 @@
-# Documentation for MonetDB NodeJS connector v0.\*
-
-> **The v0.\* version is no longer maintained. Therefore, we strongly encourage everyone using the v0.\* version to switch to the v1.\* version.**
-> For information on how to upgrade, see the [major changes](https://github.com/MonetDB/monetdb-nodejs#changes), and the [backward compatibility](#callbackwrapper).
-
-# Installation
-npm install [-g] monetdb
-
-# Example usage:
-
-```
-var options = {
-	host     : 'localhost', 
-	port     : 50000, 
-	dbname   : 'mydb', 
-	user     : 'monetdb', 
-	password : 'monetdb'
-};
-
-var conn = require('monetdb').connect(options , function(err) {
-	if (!err) console.log('connected');
-});
-
-conn.query('SELECT 1', function(err, res) {
-	if (!err) console.log(res);
-});
-
-conn.query('SELECT id FROM tables WHERE name=? and readonly=?', 
-	['connections', false], function(err, res) {
-	if (!err) console.log(res);
-});
-
-conn.close();
-```
-
-# API
-
-#### <a name="connect"></a>connect(options, fn)
-Obtain a MonetDBConnection object that tries to connect to a MonetDB server process using the provided options.
-
-- options [object]: Options to use for this connection. Possible options are:
-	- host [string]: hostname to connect to (default: localhost)
-	- port [integer]: port on which the MonetDB server process is listening (default: 50000)
-	- dbname [string]: name of the database to use (default: demo)
-	- user [string]: username to use for logging in (default: monetdb)
-	- password [string]: password to use for logging in (default: monetdb)
-	- language [string]: query language to use (default: sql)
-	- debug [boolean]: whether or not to initialize the connection in debug node (default: false)
-	- q [function]: in case you want to use promises, you should pass in the result of require('q') in here. See [Q Integration](#q) for more information on our Q integration.
-- fn [function]: Callback function to call whenever the connection succeeds or fails. This function receives one argument, which contains an error string on failure or null on success. Note: this function might be called multiple times when the MonetDB connection fails after it first succeeded. In that case, the callback will first be called indicating success, and later again with an error message.
-
-Returns an instance of a MonetDBConnection object. Note that thanks to a queueing system, this object can immediately receive queries when it is returned, even if the connection is not established yet.
-
----
-
-#### <a name="query"></a>MonetDBConnection.query(query, [params], [raw], fn)
-Run a query against this MonetDBConnection
-
-- query [string]: A query string in the chosen language, where values may be replaced by question marks, in which case the params array must be set (note: when the params array is given, the MonetDBConnection.prepare will be used under the hood).
-- params [array]: In case question marks are given for some values in the query, this array supplies the query method with the values to fill in. (default: null)
-- raw [boolean]: If set to true, a raw query is expected, including an initial 's' and a trailing ';'. (default: false)
-- fn [function]: Callback function that will be called when the query completes. It then receives two arguments:
-	- err: Error string if an error occurred, null if the query succeeded
-	- result: The [query result](#result)
-
----
-
-#### <a name="result"></a>Query result
-A query returns a query result object. This object has the following properties:
-
-- data [array]: When a SELECT query was done, this array contains the resulting data from the database. It is passed as an array of arrays, where every inner array represents one data tuple.
-- col [object]: Object that maps column names to query result indices. So if you for example did SELECT a, b FROM ... you can access b in a tuple array by issuing tuple[result.col.b], which in this case would resolve to tuple[1].
-- rows [integer]: The number of rows in the result set
-- cols [integer]: The number of columns in the result set
-- structure [array]: An array containing an object for every column, with information about the column (like from which table it came, what its name is etc.)
-- queryid [integer]: A unique identifier for this query
-- type: The type of the result (currently only 'table' is supported)
-
----
-
-#### MonetDBConnection.prepare(query, fn)
-Prepares a query for repeated execution.
-
-- query [string]: The query that has to be prepared. In this query, actual values can be replaced by question marks.
-- fn [function]: Callback function that will be called when the preparation finished. It gets passed two arguments. The first argument is an error string or null on success, the second argument is an object with the following properties:
-	- prepare: The [query result](#result) of the prepare statement
-	- exec: A function that you can call if you want to execute your prepared statement. It takes two parameters, the first one is an array with the query parameters and the second is a callback that gets executed when the execution of the prepared statement finishes (same as callback to [MonetDBConnection.query](#query)).
-	- release: A function that you can call when you want to free the resources used by your prepared statement. After calling this function, calls to the exec function will fail.
-
----
-
-#### MonetDBConnection.close(fn)
-Empty the query queue and then close the connection. Note that whenever queries arrive after the close has been issued, these queries will also be processed before the connection is closed. The connection really is not closed before it encounters an empty message queue.
-- fn [function]: Callback function that will be called when the connection is closed. Since failure never happens, it will always be called with its first argument set to null. The second argument is never given, since there is no result associated with closing the connection.
-
-
-
-# <a name="log"></a>Query logging
-Every time a query result is returned from the database, the callback function *conn.log_callback*, which defaults to null, will be executed right before the query callback function is executed (conn refers to a connection object returned by the [connect function](#connect)). If you have some general behavior that you want to be executed every time a query finishes, you can set *conn.log_callback* to a function with the following signature:
-
-function(query, err, res)
-- query: the SQL query that lead to this result (note: if you pass a params array to the [query function](#query), multiple queries are fired to the database, hence the log callback will be called multiple times)
-- err, res: Same as in the callback for the [query function](#query)
-
-
-# <a name="q"></a>Q Integration
-Due to the huge popularity of the [Q module for NodeJS](https://www.npmjs.org/package/q), we decided to add native Q support, that wraps our API in a promise returning API that exists on top of the original API, so you can use both interchangeably. 
-
-We did not want to add Q as a dependency of our module and therefore, if you want to use the promise returning functions, you have to pass in the result of require('q') to the connection options when calling the [connect function](#connect).
-
-All of the promise returning functions take the same arguments as the original functions they wrap, except for the callback argument.
-
-The promise returning functions are:
-- connectQ: Gets resolved with the connection object when the connection has been successfully initialized and gets rejected if the connection could not be established. Note that, since promises can by definition only be resolved once, failure of the connection after the promise has been resolved can not be detected using this function (you can detect this with the [original connect function](#connect).
-- queryQ
-- prepareQ
-- closeQ
-
-### Example usage of Q integration
-```
-var conn = null;
-monetdb.connectQ({dbname:"blaeu"}).then(function(c) {
-    conn = c;
-    return conn.queryQ("CREATE TABLE coords (x INT, y INT)").then(function() {
-        return conn.queryQ("INSERT INTO coords VALUES (1, 1), (2, 5), (9, 1)");
-    }).then(function() {
-        return conn.queryQ("SELECT * FROM coords WHERE x < ? AND y < ?", [4, 5]);
-    }).then(function(data) {
-        console.log(data);
-    });
-}).fail(function(err) {
-    console.log("Something went wrong: "+err);
-}).fin(function() {
-    conn && conn.closeQ().then(function() {
-    	console.log("Connection successfully closed!");
-    });
-}).done();
-```

package/docs/v1/MapiConnection.md

@@ -1,53 +0,0 @@
-# The MapiConnection object
-
-[![Build Status](https://travis-ci.org/MonetDB/monetdb-nodejs.svg)](https://travis-ci.org/MonetDB/monetdb-nodejs)
-[![Coverage Status](https://coveralls.io/repos/MonetDB/monetdb-nodejs/badge.svg?branch=master&service=github)](https://coveralls.io/github/MonetDB/monetdb-nodejs?branch=master)
-[![npm version](https://badge.fury.io/js/monetdb.svg)](https://badge.fury.io/js/monetdb)
-[![Dependency Status](https://david-dm.org/MonetDB/monetdb-nodejs.svg)](https://david-dm.org/MonetDB/monetdb-nodejs)
-
-The MapiConnection object manages the socket connection to the server, and communicates over this socket. 
-It also contains the reconnect logic.
-
-The MonetDB NodeJS module does not expose the constructor of the MapiConnection directly, since for normal usage a 
-MapiConnection object should be managed by a [MonetDBConnection object](https://github.com/MonetDB/monetdb-nodejs#mdbconnection).
-You can however use a MapiConnection object directly, since every MonetDBConnection object exposes one.
-
-If you insist, you could also include src/mapi-connection.js directly into your project to be able to construct one yourself.
-
-<a name="constructor"></a>
-### MapiConnection(\[options\])
-Construct a MapiConnection object. For the available options in the options object, [see here](https://github.com/MonetDB/monetdb-nodejs#options).
-
-**Note: As opposed to the [MonetDBConnection object](#https://github.com/MonetDB/monetdb-nodejs#mdbconnection), 
-the options are not checked for validity on constructing a MapiConnection object. This might cause unexpected behavior,
-since we do not test the creation of a MapiConnection object other than by a MonetDBConnection object.**
-
-<a name="connect"></a>
-### .connect()
-This method is documented int the [MonetDBConnection object section](https://github.com/MonetDB/monetdb-nodejs#mdbconnection_connect).
-
-<a name="request"></a>
-### .request(request)
-Adds a Mapi request to the queue. If you want to issue an SQL query this way, you should pack it in between an 's' and a ';':
-
-```javascript
-mapiConn.request('sSELECT * FROM foo;');
-```
-
-Returns a promise that resolves with a [query result](https://github.com/MonetDB/monetdb-nodejs#mdbconnection_query), or
-gets rejected with a proper error message.
-
-<a name="getstate"></a>
-### .getState()
-This method is documented in the [MonetDBConnection object section](https://github.com/MonetDB/monetdb-nodejs#mdbconnection_getstate).
-
-
-<a name="close"></a>
-### .close()
-This method is documented in the [MonetDBConnection object section](https://github.com/MonetDB/monetdb-nodejs#mdbconnection_close).
-
-
-<a name="destroy"></a>
-### .destroy(\[msg\])
-This method is documented in the [MonetDBConnection object section](https://github.com/MonetDB/monetdb-nodejs#mdbconnection_destroy).
-