Add partitioned database support.

smithsz · smithsz · commit d4003759b006 · 2019-05-09T09:37:22.000+01:00
diff --git a/CHANGES.md b/CHANGES.md
@@ -1,3 +1,6 @@
+# UNRELEASED
+- [NEW] Added partitioned database support.
+
 # 4.0.0 (2019-03-12)
 - [NEW] Added option for client to authenticate with IAM token server.
 - [FIXED] Add `vcapServiceName` configuration option to TS declarations.
diff --git a/cloudant.js b/cloudant.js
@@ -1,4 +1,4 @@
-// Copyright © 2015, 2018 IBM Corp. All rights reserved.
+// Copyright © 2015, 2019 IBM Corp. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -25,6 +25,18 @@ const Client = require('./lib/client.js');
 // return a URL.
 var reconfigure = require('./lib/reconfigure.js');
 
+// Helper function for optional parameter `opts`.
+function getCallback(opts, callback) {
+  if (typeof opts === 'function') {
+    callback = opts;
+    opts = {};
+  }
+  if (typeof opts === 'undefined') {
+    opts = {};
+  }
+  return {opts, callback};
+}
+
 // This IS the Cloudant API. It is mostly nano, with a few functions.
 function Cloudant(options, callback) {
   debug('Initialize', options);
@@ -150,7 +162,81 @@ function Cloudant(options, callback) {
         body: query}, callback);
     };
 
+    // Partitioned Databases
+    // ---------------------
+
+    function partitionInfo(partitionKey, callback) {
+      return nano.request(
+        {db: db, path: '_partition/' + partitionKey}, callback
+      );
+    }
+
+    function executePartitionedView(partitionKey, ddoc, viewName, meta, qs, callback) {
+      meta.viewPath = '_partition/' + partitionKey + '/_design/' + ddoc + '/_' +
+        meta.type + '/' + viewName;
+      // Note: No need to pass `ddoc` or `viewName` to the `baseView` function
+      // as they are passed in the `meta.viewPath`.
+      return nano._use(db).baseView(null, null, meta, qs, callback);
+    }
+
+    function partitionedList(partitionKey, qs0, callback0) {
+      const {opts, callback} = getCallback(qs0, callback0);
+      let path = '_partition/' + partitionKey + '/_all_docs';
+      return nano.request({db: db, path: path, qs: opts}, callback);
+    }
+
+    function partitionedListAsStream(partitionKey, qs) {
+      let path = '_partition/' + partitionKey + '/_all_docs';
+      return nano.request(
+        {db: db, path: path, qs: qs, stream: true}, callback
+      );
+    }
+
+    function partitionedFind(partitionKey, selector, callback) {
+      return nano.request({
+        db: db,
+        path: '_partition/' + partitionKey + '/_find',
+        method: 'POST',
+        body: selector
+      }, callback);
+    }
+
+    function partitionedFindAsStream(partitionKey, selector) {
+      return nano.request({
+        db: db,
+        path: '_partition/' + partitionKey + '/_find',
+        method: 'POST',
+        body: selector,
+        stream: true
+      });
+    }
+
+    function partitionedSearch(partitionKey, ddoc, viewName, qs, callback) {
+      return executePartitionedView(
+        partitionKey, ddoc, viewName, {type: 'search'}, qs, callback
+      );
+    }
+
+    function partitionedSearchAsStream(partitionKey, ddoc, viewName, qs) {
+      return executePartitionedView(
+        partitionKey, ddoc, viewName, {type: 'search', stream: true}, qs
+      );
+    }
+
+    function partitionedView(partitionKey, ddoc, viewName, qs, callback) {
+      return executePartitionedView(
+        partitionKey, ddoc, viewName, {type: 'view'}, qs, callback
+      );
+    }
+
+    function partitionedViewAsStream(partitionKey, ddoc, viewName, qs) {
+      return executePartitionedView(
+        partitionKey, ddoc, viewName, {type: 'view', stream: true}, qs
+      );
+    }
+
     var obj = nano._use(db);
+
     obj.geo = geo;
     obj.bulk_get = bulk_get; // eslint-disable-line camelcase
     obj.get_security = get_security; // eslint-disable-line camelcase
@@ -159,6 +245,16 @@ function Cloudant(options, callback) {
     obj.index.del = index_del; // eslint-disable-line camelcase
     obj.find = find;
 
+    obj.partitionInfo = partitionInfo;
+    obj.partitionedFind = partitionedFind;
+    obj.partitionedFindAsStream = partitionedFindAsStream;
+    obj.partitionedList = partitionedList;
+    obj.partitionedListAsStream = partitionedListAsStream;
+    obj.partitionedSearch = partitionedSearch;
+    obj.partitionedSearchAsStream = partitionedSearchAsStream;
+    obj.partitionedView = partitionedView;
+    obj.partitionedViewAsStream = partitionedViewAsStream;
+
     return obj;
   };
 
diff --git a/test/partitioned_databases.js b/test/partitioned_databases.js
@@ -0,0 +1,219 @@
+// Copyright © 2019 IBM Corp. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/* global describe it before after */
+'use strict';
+
+const assert = require('assert');
+const async = require('async');
+const Cloudant = require('../cloudant.js');
+const nock = require('./nock.js');
+const uuidv4 = require('uuid/v4'); // random
+
+const ME = process.env.cloudant_username || 'nodejs';
+const PASSWORD = process.env.cloudant_password || 'sjedon';
+const SERVER = process.env.SERVER_URL || `https://${ME}.cloudant.com`;
+const DBNAME = `nodejs-cloudant-${uuidv4()}`;
+
+describe('Partitioned Databases #db', () => {
+  const partitionKeys = Array.apply(null, {length: 10})
+        .map(() => { return uuidv4(); });
+
+  before(() => {
+    var mocks = nock(SERVER)
+      .put(`/${DBNAME}`)
+      .query({ partitioned: true })
+      .reply(201, { ok: true });
+
+    const cloudant = Cloudant({ url: SERVER, username: ME, password: PASSWORD });
+    return cloudant.db.create(DBNAME, { partitioned: true }).then((body) => {
+      assert.ok(body.ok);
+      mocks.done();
+    });
+  });
+
+  after(() => {
+    var mocks = nock(SERVER)
+      .delete(`/${DBNAME}`)
+      .reply(200, { ok: true });
+
+    var cloudant = Cloudant({ url: SERVER, username: ME, password: PASSWORD });
+    return cloudant.db.destroy(DBNAME).then((body) => {
+      assert.ok(body.ok);
+      mocks.done();
+    });
+  });
+
+  it('created a partitioned database', () => {
+    var mocks = nock(SERVER)
+      .get(`/${DBNAME}`)
+      .reply(200, { props: { partitioned: true } });
+
+    const cloudant = Cloudant({ url: SERVER, username: ME, password: PASSWORD });
+    return cloudant.db.get(DBNAME).then((body) => {
+      assert.ok(body.props.partitioned);
+      mocks.done();
+    });
+  });
+
+  it('create some partitioned documents', function(done) {
+    if (!process.env.NOCK_OFF) {
+      this.skip();
+    }
+    const cloudant = Cloudant({ url: SERVER, username: ME, password: PASSWORD });
+    const db = cloudant.db.use(DBNAME);
+
+    var q = async.queue(function(task, callback) {
+      db.bulk({ 'docs': task.docs }).then(callback).catch(done);
+    }, 10);
+    q.drain = done;
+
+    for (let i in partitionKeys) {
+      let docs = [];
+      for (let j = 0; j < 10; j++) {
+        docs.push({ _id: `${partitionKeys[i]}:doc${j}`, foo: 'bar' });
+      }
+      q.push({ 'docs': docs });
+    }
+  });
+
+  it('get partition information', () => {
+    const pKey = partitionKeys[0];
+
+    var mocks = nock(SERVER)
+      .get(`/${DBNAME}/_partition/${pKey}`)
+      .reply(200, { partition: pKey, doc_count: 10 });
+
+    const cloudant = Cloudant({ url: SERVER, username: ME, password: PASSWORD });
+    const db = cloudant.db.use(DBNAME);
+    return db.partitionInfo(pKey).then((body) => {
+      assert.equal(body.partition, pKey);
+      assert.equal(body.doc_count, 10);
+      mocks.done();
+    });
+  });
+
+  it('get all documents in a partition', () => {
+    const pKey = partitionKeys[0];
+
+    var mocks = nock(SERVER)
+      .get(`/${DBNAME}/_partition/${pKey}/_all_docs`)
+      .reply(200, { rows: new Array(10) });
+
+    const cloudant = Cloudant({ url: SERVER, username: ME, password: PASSWORD });
+    const db = cloudant.db.use(DBNAME);
+    return db.partitionedList(pKey).then((body) => {
+      assert.equal(body.rows.length, 10);
+      mocks.done();
+    });
+  });
+
+  describe('Partitioned Query', () => {
+    before(() => {
+      if (!process.env.NOCK_OFF) {
+        return;
+      }
+      const cloudant = Cloudant({ url: SERVER, username: ME, password: PASSWORD });
+      const db = cloudant.db.use(DBNAME);
+      return db.createIndex({ index: { fields: ['foo'] } }).then((body) => {
+        assert.equal(body.result, 'created');
+      });
+    });
+
+    it('query a partitioned query', () => {
+      const pKey = partitionKeys[0];
+      const selector = { selector: { foo: { $eq: 'bar' } } };
+
+      var mocks = nock(SERVER)
+        .post(`/${DBNAME}/_partition/${pKey}/_find`, selector)
+        .reply(200, { docs: new Array(10) });
+
+      const cloudant = Cloudant({ url: SERVER, username: ME, password: PASSWORD });
+      const db = cloudant.db.use(DBNAME);
+      return db.partitionedFind(pKey, selector).then((body) => {
+        assert(body.docs.length, 10);
+        mocks.done();
+      });
+    });
+  });
+
+  describe('Partitioned Search', () => {
+    before(() => {
+      if (!process.env.NOCK_OFF) {
+        return;
+      }
+      const cloudant = Cloudant({ url: SERVER, username: ME, password: PASSWORD });
+      const db = cloudant.db.use(DBNAME);
+      return db.insert({
+        _id: '_design/mysearch',
+        options: { partitioned: true },
+        indexes: {
+          search1: {
+            index: 'function(doc) { index("id", doc._id, {"store": true}); }'
+          }
+        }
+      }).then((body) => {
+        assert.ok(body.ok);
+      });
+    });
+
+    it('query a partitioned search', () => {
+      const pKey = partitionKeys[0];
+
+      var mocks = nock(SERVER)
+        .post(`/${DBNAME}/_partition/${pKey}/_design/mysearch/_search/search1`,
+              { q: '*:*' })
+        .reply(200, { rows: new Array(10) });
+
+      const cloudant = Cloudant({ url: SERVER, username: ME, password: PASSWORD });
+      const db = cloudant.db.use(DBNAME);
+      return db.partitionedSearch(pKey, 'mysearch', 'search1', { q: '*:*' }).then((body) => {
+        assert(body.rows.length, 10);
+        mocks.done();
+      });
+    });
+  });
+
+  describe('Partitioned View', () => {
+    before(() => {
+      if (!process.env.NOCK_OFF) {
+        return;
+      }
+      const cloudant = Cloudant({ url: SERVER, username: ME, password: PASSWORD });
+      const db = cloudant.db.use(DBNAME);
+      return db.insert({
+        _id: '_design/myview',
+        options: { partitioned: true },
+        views: { view1: { map: 'function(doc) { emit(doc._id, 1); }' } }
+      }).then((body) => {
+        assert.ok(body.ok);
+      });
+    });
+
+    it('query a partitioned view', () => {
+      const pKey = partitionKeys[0];
+
+      var mocks = nock(SERVER)
+        .get(`/${DBNAME}/_partition/${pKey}/_design/myview/_view/view1`)
+        .reply(200, { rows: new Array(10) });
+
+      const cloudant = Cloudant({ url: SERVER, username: ME, password: PASSWORD });
+      const db = cloudant.db.use(DBNAME);
+      return db.partitionedView(pKey, 'myview', 'view1').then((body) => {
+        assert(body.rows.length, 10);
+        mocks.done();
+      });
+    });
+  });
+});
diff --git a/types/index.d.ts b/types/index.d.ts
