aerospike 4.0.2 → 5.0.1

package/binding.gyp

@@ -71,7 +71,6 @@
         'src/main/query.cc',
         'src/main/scan.cc',
         'src/main/expressions.cc',
-        'src/main/predexp.cc',
         'src/main/async.cc',
         'src/main/command.cc',
         'src/main/commands/apply_async.cc',
@@ -79,6 +78,9 @@
         'src/main/commands/batch_get.cc',
         'src/main/commands/batch_select.cc',
         'src/main/commands/batch_read_async.cc',
+        'src/main/commands/batch_remove.cc',
+        'src/main/commands/batch_apply.cc',
+        'src/main/commands/batch_write_async.cc',
         'src/main/commands/exists_async.cc',
         'src/main/commands/get_async.cc',
         'src/main/commands/info_any.cc',
@@ -114,8 +116,10 @@
         'src/main/enums/ttl.cc',
         'src/main/enums/config_enum.cc',
         'src/main/enums/exp_enum.cc',
+        'src/main/enums/batch_type.cc',
         'src/main/stats.cc',
         'src/main/util/conversions.cc',
+        'src/main/util/conversions_batch.cc',
         'src/main/util/log.cc'
       ],
       'configurations': {
@@ -134,7 +138,6 @@
       'conditions': [
         ['OS=="linux"',{
           'libraries': [
-            '../libuv-v1.8.0/.libs/libuv.a',
             '../aerospike-client-c/target/Linux-x86_64/lib/libaerospike.a',
             '-lz',
             '-lssl'
@@ -152,9 +155,9 @@
         }],
         ['OS=="mac"',{
           'libraries': [
-            '../libuv-v1.8.0/.libs/libuv.a',
             '../aerospike-client-c/target/Darwin-x86_64/lib/libaerospike.a',
-            '-lz'
+            '-lz',
+            '-lssl'
           ],
           'defines': [
             'AS_USE_LIBUV'

package/examples/batch.js

@@ -28,7 +28,7 @@ async function batchRead (client, argv) {
     if (argv.bins) {
       request.bins = argv.bins
     } else {
-      request.read_all_bins = true
+      request.readAllBins = true
     }
     return request
   })

package/examples/put_test.js

@@ -0,0 +1,72 @@
+const Aerospike = require('aerospike')
+
+const config = {
+  hosts: '172.17.0.3:3000',
+  log: {
+    level: Aerospike.log.DEBUG,
+    file: process.stdout.fd
+  }
+}
+const key = new Aerospike.Key('test', 'demo', 'demo')
+
+// process.on('uncaughtException', (err, origin) => {
+//   fs.writeSync(
+//     process.stderr.fd,
+//     `Caught exception: ${err}\n` +
+//     `Exception origin: ${origin}`
+//   );
+// });
+
+console.log('Connect')
+Aerospike.connect(config)
+  .then(client => {
+    const bins = {
+      i: 123,
+      s: 'hello',
+      b: Buffer.from('world'),
+      d: new Aerospike.Double(3.1415),
+      g: new Aerospike.GeoJSON({ type: 'Point', coordinates: [103.913, 1.308] }),
+      l: [1, 'a', { x: 'y' }],
+      m: { foo: 4, bar: 7 }
+    }
+    const meta = { ttl: 0 }
+    const policy = new Aerospike.WritePolicy({
+      exists: Aerospike.policy.exists.CREATE_OR_REPLACE,
+      timeout: 20000
+    })
+
+    console.log('Put')
+    return client.put(key, bins, meta, policy)
+      .then(() => {
+        const ops = [
+          Aerospike.operations.incr('i', 1),
+          Aerospike.operations.read('i'),
+          Aerospike.lists.append('l', 'z'),
+          Aerospike.maps.removeByKey('m', 'bar')
+        ]
+
+        console.log('Operate')
+        return client.operate(key, ops)
+      })
+      .then(result => {
+        console.log(result.bins) // => { c: 4, i: 124, m: null }
+
+        return client.get(key)
+      })
+      .then(record => {
+        console.log(record.bins) // => { i: 124,
+        //      s: 'hello',
+        //      b: <Buffer 77 6f 72 6c 64>,
+        //      d: 3.1415,
+        //      g: '{"type":"Point","coordinates":[103.913,1.308]}',
+        //      l: [ 1, 'a', { x: 'y' }, 'z' ],
+        //      m: { foo: 4 } }
+      })
+      .then(() => client.close())
+      .catch(error => {
+        console.log('Error')
+        client.close()
+        return Promise.reject(error)
+      })
+  })
+  .catch(error => console.log(error))

package/lib/aerospike.js

@@ -42,15 +42,6 @@ const utils = require('./utils')
  */
 exports.filter = require('./filter')
 
-/**
- * The {@link module:aerospike/predexp|predexp} module provides functions to
- * create predicate expressions for use in query operations via the {@link
- * Client#query} command.
- *
- * @summary {@link module:aerospike/predexp|aerospike/predexp} module
- */
-exports.predexp = require('./predexp')
-
 /**
  * The {@link module:aerospike/exp|exp} module provides functions to
  * create expressions for use in key operations via the {@link
@@ -66,7 +57,6 @@ exp.type = as.exp.type
  * @readonly
  * @enum {number}
  *
- * @see {@link module:aerospike/predexp.stringRegex} for usage.
  */
 exports.regex = {
   /** Use basic regular expression syntax. */
@@ -150,12 +140,12 @@ exports.bitwise = require('./bitwise')
 exports.operations = require('./operations')
 
 /**
- * The {@link module:aerospike/expoperations|ExpOperations} module provides functions
+ * The {@link module:aerospike/exp_operations|ExpOperation} module provides functions
  * to create operations using <a href="https://docs.aerospike.com/guide/expressions">&uArr;Aerospike Expressions</a>
  * for the {@link Client#operate} command.
  *
  *
- * @summary {@link module:aerospike/operations|aerospike/exp_operations} module
+ * @summary {@link module:aerospike/exp_operations|aerospike/exp_operations} module
  */
 exp.operations = require('./exp_operations')
 
@@ -169,18 +159,23 @@ exp.operations = require('./exp_operations')
 const policy = exports.policy = require('./policy')
 
 // short-cuts to the policy classes defined under the policy module
+exports.BasePolicy = policy.BasePolicy
 exports.ApplyPolicy = policy.ApplyPolicy
 exports.BatchPolicy = policy.BatchPolicy
-exports.CommandQueuePolicy = policy.CommandQueuePolicy
-exports.InfoPolicy = policy.InfoPolicy
-exports.ListPolicy = policy.ListPolicy
-exports.MapPolicy = policy.MapPolicy
 exports.OperatePolicy = policy.OperatePolicy
 exports.QueryPolicy = policy.QueryPolicy
 exports.ReadPolicy = policy.ReadPolicy
 exports.RemovePolicy = policy.RemovePolicy
 exports.ScanPolicy = policy.ScanPolicy
 exports.WritePolicy = policy.WritePolicy
+exports.BatchApplyPolicy = policy.BatchApplyPolicy
+exports.BatchReadPolicy = policy.BatchReadPolicy
+exports.BatchRemovePolicy = policy.BatchRemovePolicy
+exports.BatchWritePolicy = policy.BatchWritePolicy
+exports.CommandQueuePolicy = policy.CommandQueuePolicy
+exports.InfoPolicy = policy.InfoPolicy
+exports.ListPolicy = policy.ListPolicy
+exports.MapPolicy = policy.MapPolicy
 
 /**
  * The {@link module:aerospike/status|status} module contains a list of the

package/lib/client.js

@@ -346,10 +346,11 @@ Client.prototype.batchGet = function (keys, policy, callback) {
  * This method allows different namespaces/bins to be requested for each key in
  * the batch. This method requires server >= 3.6.0.
  *
- * @param {object[]} records - List of keys and bins to retrieve.
- * @param {Key} records[].key - Key to retrieve.
+ * @param {object[]} records - {@link Record} List of keys and bins to retrieve.
+ * @param {type} records[].type - {@link Record#type} Batch type.
+ * @param {Key} records[].key - Record Key.
  * @param {string[]} [records[].bins] - List of bins to retrieve.
- * @param {boolean} [records[].read_all_bins] - Whether to retrieve all bins or
+ * @param {boolean} [records[].readAllBins] - Whether to retrieve all bins or
  * just the meta data of the record. If true, ignore <code>bins</code> and read
  * all bins; if false and <code>bins</code> is specified, read specified bins;
  * if false and <code>bins</code> is not specified, read only record meta data
@@ -367,9 +368,12 @@ Client.prototype.batchGet = function (keys, policy, callback) {
  *
  * const Aerospike = require('aerospike')
  * var batchRecords = [
- *   { key: new Aerospike.Key('test', 'demo', 'key1'), bins: ['i', 's'] },
- *   { key: new Aerospike.Key('test', 'demo', 'key2'), read_all_bins: true },
- *   { key: new Aerospike.Key('test', 'demo', 'key3') }
+ *   { type: batchType.BATCH_READ,
+ *     key: new Aerospike.Key('test', 'demo', 'key1'), bins: ['i', 's'] },
+ *   { type: batchType.BATCH_READ,
+ *     key: new Aerospike.Key('test', 'demo', 'key2'), readAllBins: true },
+ *   { type: batchType.BATCH_READ,
+ *     key: new Aerospike.Key('test', 'demo', 'key3') }
  * ]
  * Aerospike.connect(function (error, client) {
  *   if (error) throw error
@@ -391,6 +395,246 @@ Client.prototype.batchRead = function (records, policy, callback) {
   return cmd.execute()
 }
 
+/**
+ * @function Client#batchWrite
+ *
+ * @summary Read/Write multiple records for specified batch keys in one batch call.
+ *
+ * @description
+ *
+ * This method allows different sub-commands for each key in the batch.
+ * This method requires server >= 6.0.0.
+ *
+ * @param {object[]} records - {@link Record} List of batch sub-commands to perform.
+ * @param {type} records[].type - {@link Record#type} Batch type.
+ * @param {Key} records[].key - Record Key.
+ * @param {BatchPolicy} [policy] - The Batch Policy to use for this operation.
+ * @param {batchRecordsCallback} [callback] - The function to call when
+ * the operation completes, with the results of the batch operation.
+ *
+ * @returns {?Promise} - If no callback function is passed, the function
+ * returns a Promise that resolves to the results of the batch operation.
+ *
+ * @since v5.0.0
+ *
+ * @example
+ * const Aerospike = require('aerospike')
+ * const batchType = as.batchTypes
+ * var batchRecords = [
+ *   { type: batchType.BATCH_READ,
+ *     key: new Aerospike.Key('test', 'demo', 'key1'),
+ *     bins: ['i', 's'] },
+ *   { type: batchType.BATCH_READ,
+ *     key: new Aerospike.Key('test', 'demo', 'key2'),
+ *     readAllBins: true },
+ *   { type: batchType.BATCH_WRITE,
+ *     key: new Aerospike.Key('test', 'demo', 'key3'),
+ *     ops:[
+ *          op.write('geo', new GeoJSON({ type: 'Point', coordinates: [123.456, 1.308] })),
+ *          op.write('blob', Buffer.from('bar'))
+ *         ],
+ *     policy: new Aerospike.BatchWritePolicy({
+ *         filterExpression: exp.eq(exp.binInt('i'), exp.int(37)),
+ *         key: Aerospike.policy.key.SEND,
+ *         commitLevel: Aerospike.policy.commitLevel.ALL,
+ *         gen: Aerospike.policy.gen.EQ,
+ *         exists: Aerospike.policy.exists.CREATE,
+ *         durableDelete: true
+ *       })},
+ *   { type: batchType.BATCH_REMOVE,
+ *     key: new Aerospike.Key('test', 'demo', 'key5'),
+ *     policy: new Aerospike.BatchRemovePolicy({
+ *         filterExpression: exp.eq(exp.binInt('i'), exp.int(37)),
+ *         key: Aerospike.policy.key.SEND,
+ *         commitLevel: Aerospike.policy.commitLevel.ALL,
+ *         gen: Aerospike.policy.gen.EQ,
+ *         durableDelete: true
+ *       })},
+ *    }
+ * ]
+ * Aerospike.connect(function (error, client) {
+ *   if (error) throw error
+ *   client.batchWrite(batchRecords, function (error, results) {
+ *     if (error) throw error
+ *     results.forEach(function (result) {
+ *       console.log(result)
+ *     })
+ *   })
+ * })
+ */
+Client.prototype.batchWrite = function (records, policy, callback) {
+  if (typeof policy === 'function') {
+    callback = policy
+    policy = null
+  }
+
+  const cmd = new Commands.BatchWrite(this, [records, policy], callback)
+  return cmd.execute()
+}
+
+/**
+ * @function Client#batchApply
+ *
+ * @summary Apply UDF (user defined function) on multiple keys.
+ *
+ * @description
+ *
+ * This method allows multiple sub-commands for each key in the batch.
+ * This method requires server >= 6.0.0.
+ *
+ * @param {object[]} records - {@link Record} List of batch sub-commands to perform.
+ * @param {type} records[].type - {@link Record#type} Batch type.
+ * @param {Key} records[].key - Record Key.
+ * @param {object[]} udf - Server UDF module/function and argList to apply.
+ * @param {BatchPolicy} [batchPolicy] - The Batch Policy to use for this operation.
+ * @param {BatchApplyPolicy} [batchApplyPolicy] UDF policy configuration parameters.
+ * @param {batchRecordsCallback} [callback] - The function to call when
+ * the operation completes, with the results of the batch operation.
+ *
+ * @returns {?Promise} - If no callback function is passed, the function
+ * returns a Promise that resolves to the results of the batch operation.
+ *
+ * @since v5.0.0
+ *
+ * @example
+ * const Aerospike = require('aerospike')
+ * const batchType = as.batchTypes
+ * var batchRecords = [
+ *   { type: batchType.BATCH_READ,
+ *     key: new Aerospike.Key('test', 'demo', 'key1'),
+ *     bins: ['i', 's'] },
+ *   { type: batchType.BATCH_READ,
+ *     key: new Aerospike.Key('test', 'demo', 'key2'),
+ *     readAllBins: true },
+ *   { type: batchType.BATCH_APPLY,
+ *     key: new Aerospike.Key('test', 'demo', 'key4'),
+ *     policy: new Aerospike.BatchApplyPolicy({
+ *         filterExpression: exp.eq(exp.binInt('i'), exp.int(37)),
+ *         key: Aerospike.policy.key.SEND,
+ *         commitLevel: Aerospike.policy.commitLevel.ALL,
+ *         durableDelete: true
+ *       }),
+ *     udf: {
+ *          module: 'udf',
+ *          funcname: 'function1',
+ *          args: [[1, 2, 3]]
+ *          }
+ *   },
+ *   { type: batchType.BATCH_APPLY,
+ *     key: new Aerospike.Key('test', 'demo', 'key5'),
+ *     policy: new Aerospike.BatchApplyPolicy({
+ *         filterExpression: exp.eq(exp.binInt('i'), exp.int(37)),
+ *         key: Aerospike.policy.key.SEND,
+ *         commitLevel: Aerospike.policy.commitLevel.ALL,
+ *         durableDelete: true
+ *       }),
+ *     udf: {
+ *          module: 'udf',
+ *          funcname: 'function2',
+ *          args: [[1, 2, 3]]
+ *          }
+ *    }
+ * ]
+ * Aerospike.connect(function (error, client) {
+ *   if (error) throw error
+ *   client.batchApply(batchRecords, udf, function (error, results) {
+ *     if (error) throw error
+ *     results.forEach(function (result) {
+ *       console.log(result)
+ *     })
+ *   })
+ * })
+ */
+Client.prototype.batchApply = function (records, udf, batchPolicy, batchApplyPolicy, callback) {
+  if (typeof batchPolicy === 'function') {
+    callback = batchPolicy
+    batchPolicy = null
+    batchApplyPolicy = null
+  } else {
+    if (typeof batchApplyPolicy === 'function') {
+      callback = batchApplyPolicy
+      batchApplyPolicy = null
+    }
+  }
+
+  const cmd = new Commands.BatchApply(this, [records, udf, batchPolicy, batchApplyPolicy], callback)
+  return cmd.execute()
+}
+
+/**
+ * @function Client#batchRemove
+ *
+ * @summary Remove multiple records.
+ *
+ * @description
+ *
+ * This method allows multi sub-commands for each key in the batch.
+ * This method requires server >= 6.0.0.
+ *
+ * @param {object[]} records - {@link Record} List of batch sub-commands to perform.
+ * @param {type} records[].type - {@link Record#type} Batch type.
+ * @param {Key} records[].key - Record Key.
+ * @param {BatchPolicy} [batchPolicy] - The Batch Policy to use for this operation.
+ * @param {BatchRemovePolicy} [batchRemovePolicy] Remove policy configuration parameters.
+ * @param {batchRecordsCallback} [callback] - The function to call when
+ * the operation completes, with the results of the batch operation.
+ *
+ * @returns {?Promise} - If no callback function is passed, the function
+ * returns a Promise that resolves to the results of the batch operation.
+ *
+ * @since v5.0.0
+ *
+ * @example
+ * const Aerospike = require('aerospike')
+ * const batchType = as.batchTypes
+ * var batchRecords = [
+ *   { type: batchType.BATCH_REMOVE,
+ *     key: new Aerospike.Key('test', 'demo', 'key5'),
+ *     policy: new Aerospike.BatchRemovePolicy({
+ *         filterExpression: exp.eq(exp.binInt('i'), exp.int(37)),
+ *         key: Aerospike.policy.key.SEND,
+ *         commitLevel: Aerospike.policy.commitLevel.ALL,
+ *         gen: Aerospike.policy.gen.EQ,
+ *         durableDelete: true
+ *       })},
+ *    },
+ *   { type: batchType.BATCH_REMOVE,
+ *     key: new Aerospike.Key('test', 'demo', 'key6'),
+ *     policy: new Aerospike.BatchRemovePolicy({
+ *         filterExpression: exp.eq(exp.binInt('i'), exp.int(37)),
+ *         key: Aerospike.policy.key.SEND,
+ *         commitLevel: Aerospike.policy.commitLevel.ALL,
+ *         gen: Aerospike.policy.gen.EQ,
+ *         durableDelete: true
+ *       })},
+ *    }
+ * ]
+ * Aerospike.connect(function (error, client) {
+ *   if (error) throw error
+ *   client.batchRemove(batchRecords, function (error, results) {
+ *     if (error) throw error
+ *     results.forEach(function (result) {
+ *       console.log(result)
+ *     })
+ *   })
+ * })
+ */
+Client.prototype.batchRemove = function (records, batchPolicy, batchRemovePolicy, callback) {
+  if (typeof batchPolicy === 'function') {
+    callback = batchPolicy
+    batchPolicy = null
+    batchRemovePolicy = null
+  } else {
+    if (typeof batchRemovePolicy === 'function') {
+      callback = batchRemovePolicy
+      batchRemovePolicy = null
+    }
+  }
+
+  const cmd = new Commands.BatchRemove(this, [records, batchPolicy, batchRemovePolicy], callback)
+  return cmd.execute()
+}
+
 /**
  * @function Client#batchSelect
  *

package/lib/commands/index.js

@@ -29,6 +29,9 @@ exports.Apply = class ApplyCommand extends Command('applyAsync') { }
 exports.BatchExists = class BatchExistsCommand extends BatchCommand('batchExists') { }
 exports.BatchGet = class BatchGetCommand extends BatchCommand('batchGet') { }
 exports.BatchRead = class BatchReadCommand extends BatchCommand('batchRead') { }
+exports.BatchWrite = class BatchWriteCommand extends BatchCommand('batchWrite') { }
+exports.BatchApply = class BatchApplyCommand extends BatchCommand('batchApply') { }
+exports.BatchRemove = class BatchRemoveCommand extends BatchCommand('batchRemove') { }
 exports.BatchSelect = class BatchSelectCommand extends BatchCommand('batchSelect') { }
 exports.Connect = class ConnectCommand extends ConnectCommandBase('connect') { }
 exports.Exists = class ExistsCommand extends ExistsCommandBase('existsAsync') { }

package/lib/commands/query_background_command.js

@@ -24,7 +24,7 @@ function notEmpty (value) {
 }
 
 function hasFilter (queryOrScan) {
-  return notEmpty(queryOrScan.filters) || notEmpty(queryOrScan.predexp)
+  return notEmpty(queryOrScan.filters)
 }
 
 function moduleName (queryOrScan) {

package/lib/exp.js

@@ -99,7 +99,6 @@ const BIN_TYPE_UNDEF = 0
  *     })
  *   })
  * })
-
  */
 
 /*********************************************************************************

package/lib/exp_operations.js

@@ -60,7 +60,7 @@ const as = require('bindings')('aerospike.node')
 const ops = as.expOperations
 
 /**
- * @class module:aerospike/expoperations~ExpOperation
+ * @class module:aerospike/exp_operations~ExpOperation
  *
  * @classdesc class for all expression operations executed with the {@link
  * Client#operate} command.

package/lib/policies/base_policy.js

@@ -20,6 +20,8 @@
  * Base class for all client policies. The base policy defines general policy
  * values that are supported by all client policies, including timeout and
  * retry handling.
+ * Applies to {@link ApplyPolicy}, {@link BatchPolicy}, {@link OperatePolicy},
+ * {@link QueryPolicy}, {@link ReadPolicy}, {@link RemovePolicy}, {@link ScanPolicy} and {@link WritePolicy}.
  *
  * @since v3.0.0
  */
@@ -86,55 +88,11 @@ class BasePolicy {
      */
     this.maxRetries = props.maxRetries
 
-    /**
-     * Use zlib compression on write or batch read commands when the command
-     * buffer size is greater than 128 bytes. In addition, tell the server to
-     * compress it's response on read commands. The server response compression
-     * threshold is also 128 bytes.
-     *
-     * This option will increase cpu and memory usage (for extra compressed
-     * buffers), but decrease the size of data sent over the network.
-     *
-     * Requires Enterprise Server version >= 4.8.
-     *
-     * @type boolean
-     * @default: false
-     * @since v3.14.0
-     */
-    this.compress = props.compress
-
-    /**
-     * Optional predicate expression filter list in postfix notation. If the
-     * predicate expression exists and evaluates to false on the server, the
-     * transaction is ignored. This can be used to eliminate a client/server
-     * roundtrip in some cases.
-     *
-     * Predicate expression filters can only be applied to the following commands:
-     * * {@link Client#apply}
-     * * {@link Client#batchExists}
-     * * {@link Client#batchGet}
-     * * {@link Client#batchRead}
-     * * {@link Client#batchSelect}
-     * * {@link Client#exists}
-     * * {@link Client#get}
-     * * {@link Client#operate}
-     * * {@link Client#put}
-     * * {@link Client#remove}
-     * * {@link Client#select}
-     *
-     * @type Predicate[]
-     * @since v3.14.0
-     */
-    this.predexp = props.predexp
-
     /**
      * Optional expression filter. If filter exp exists and evaluates to false, the
      * transaction is ignored. This can be used to eliminate a client/server roundtrip
      * in some cases.
      *
-     * predexp and filter_exp are mutually exclusive.  If both are defined, predexp
-     * will be ignored.
-     *
      * expression filters can only be applied to the following commands:
      * * {@link Client#apply}
      * * {@link Client#batchExists}
@@ -149,6 +107,23 @@ class BasePolicy {
      * * {@link Client#select}
      */
     this.filterExpression = props.filterExpression
+
+    /**
+     * Use zlib compression on write or batch read commands when the command
+     * buffer size is greater than 128 bytes. In addition, tell the server to
+     * compress it's response on read commands. The server response compression
+     * threshold is also 128 bytes.
+     *
+     * This option will increase cpu and memory usage (for extra compressed
+     * buffers), but decrease the size of data sent over the network.
+     *
+     * Requires Enterprise Server version >= 4.8.
+     *
+     * @type boolean
+     * @default: false
+     * @since v3.14.0
+     */
+    this.compress = props.compress
   }
 }