aerospike 5.11.0 → 5.12.0

package/README.md

@@ -78,8 +78,11 @@ const config = {
 
 const key = new Aerospike.Key('test', 'demo', 'demo')
 
-Aerospike.connect(config)
-  .then(client => {
+;(async function () {
+  let client
+  try {
+    client = await Aerospike.connect(config)
+
     const bins = {
       i: 123,
       s: 'hello',
@@ -97,39 +100,32 @@ Aerospike.connect(config)
       totalTimeout : 0
     })
 
-    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')
-        ]
-
-        return client.operate(key, ops)
-      })
-      .then(result => {
-        console.log(result.bins) // => { i: 124, l: 4, 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.error('Error: %s [%i]', error.message, error.code)
-    if (error.client) {
-      error.client.close()
-    }
-  })
+
+    await client.put(key, bins, meta, policy)
+    const ops = [
+      Aerospike.operations.incr('i', 1),
+      Aerospike.operations.read('i'),
+      Aerospike.lists.append('l', 'z'),
+      Aerospike.maps.removeByKey('m', 'bar')
+    ]
+
+    await client.operate(key, ops)
+    let record = await client.get(key) 
+
+    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 } }
+  } catch (error) {
+    console.error('Error:', error)
+    process.exit(1)
+  } finally {
+    if (client) client.close()
+  }
+})()
 ```
 ## Prerequisites
 

package/binding.gyp

@@ -144,13 +144,14 @@
         'src/main/enums/config_enum.cc',
         'src/main/enums/exp_enum.cc',
         'src/main/enums/batch_type.cc',
+        'src/main/enums/query_duration.cc',
         'src/main/enums/privilege_code.cc',
         'src/main/enums/exp_read_flags.cc',
         'src/main/enums/exp_write_flags.cc',
         'src/main/stats.cc',
         'src/main/util/conversions.cc',
         'src/main/util/conversions_batch.cc',
-        'src/main/util/log.cc'
+        'src/main/util/log.cc',
       ],
       'configurations': {
         'Release': {

package/lib/binding/node-v108-win32-x64/aerospike-core-client/aerospik.95E228AA.tlog/CustomBuild.command.1.tlog

@@ -0,0 +1,3 @@
+^C:\USERS\ADMINISTRATOR\DOCUMENTS\AEROSPIKE-CLIENT-NODEJS\BINDING.GYP
+call call "pwsh" "../scripts/build-c-client.ps1" "-Configuration" "Release" "-NodeLibFile" "C:/Users/Administrator/AppData/Local/node-gyp/Cache/18.20.2/x64/node.lib"
+if %errorlevel% neq 0 exit /b %errorlevel%

package/lib/binding/node-v108-win32-x64/aerospike-core-client/aerospik.95E228AA.tlog/CustomBuild.read.1.tlog

@@ -0,0 +1 @@
+^C:\USERS\ADMINISTRATOR\DOCUMENTS\AEROSPIKE-CLIENT-NODEJS\BINDING.GYP

package/lib/binding/node-v108-win32-x64/aerospike-core-client/aerospik.95E228AA.tlog/CustomBuild.write.1.tlog

@@ -0,0 +1,3 @@
+^C:\USERS\ADMINISTRATOR\DOCUMENTS\AEROSPIKE-CLIENT-NODEJS\BINDING.GYP
+C:\USERS\ADMINISTRATOR\DOCUMENTS\AEROSPIKE-CLIENT-NODEJS\AEROSPIKE-CLIENT-C-OUTPUT\INCLUDE\AEROSPIKE\AEROSPIKE.H
+C:\USERS\ADMINISTRATOR\DOCUMENTS\AEROSPIKE-CLIENT-NODEJS\AEROSPIKE-CLIENT-C-OUTPUT\LIB\AEROSPIKE.LIB

package/lib/binding/node-v108-win32-x64/aerospike-core-client/aerospik.95E228AA.tlog/aerospike-core-client.lastbuildstate

@@ -0,0 +1,2 @@
+PlatformToolSet=v143:VCToolArchitecture=Native64Bit:VCToolsVersion=14.39.33519:TargetPlatformVersion=10.0.22621.0:
+Release|x64|C:\Users\Administrator\Documents\aerospike-client-nodejs\build\|

package/lib/policies/batch_policy.js

@@ -58,6 +58,22 @@ class BatchPolicy extends BasePolicy {
      * @see {@link module:aerospike/policy.readModeSC} for supported policy values.
      */
     this.readModeSC = props.readModeSC
+
+    /**
+     * Determine how record TTL (time to live) is affected on reads. When enabled, the server can
+     * efficiently operate as a read-based LRU cache where the least recently used records are expired.
+     * The value is expressed as a percentage of the TTL sent on the most recent write such that a read
+     * within this interval of the record’s end of life will generate a touch.
+     *
+     * For example, if the most recent write had a TTL of 10 hours and read_touch_ttl_percent is set to
+     * 80, the next read within 8 hours of the record's end of life (equivalent to 2 hours after the most
+     * recent write) will result in a touch, resetting the TTL to another 10 hours.
+     *      *
+     * @type number
+     * @default 0
+     */
+    this.readTouchTtlPercent = props.readTouchTtlPercent
+
     /**
      * Determine if batch commands to each server are run in parallel threads.
      *

package/lib/policies/batch_read_policy.js

@@ -52,6 +52,21 @@ class BatchReadPolicy {
       * @see {@link module:aerospike/policy.readModeSC} for supported policy values.
       */
     this.readModeSC = props.readModeSC
+
+    /**
+     * Determine how record TTL (time to live) is affected on reads. When enabled, the server can
+     * efficiently operate as a read-based LRU cache where the least recently used records are expired.
+     * The value is expressed as a percentage of the TTL sent on the most recent write such that a read
+     * within this interval of the record’s end of life will generate a touch.
+     *
+     * For example, if the most recent write had a TTL of 10 hours and read_touch_ttl_percent is set to
+     * 80, the next read within 8 hours of the record's end of life (equivalent to 2 hours after the most
+     * recent write) will result in a touch, resetting the TTL to another 10 hours.
+     *      *
+     * @type number
+     * @default 0
+     */
+    this.readTouchTtlPercent = props.readTouchTtlPercent
   }
 }
 

package/lib/policies/operate_policy.js

@@ -113,6 +113,21 @@ class OperatePolicy extends BasePolicy {
      * @see {@link module:aerospike/policy.readModeSC} for supported policy values.
      */
     this.readModeSC = props.readModeSC
+
+    /**
+     * Determine how record TTL (time to live) is affected on reads. When enabled, the server can
+     * efficiently operate as a read-based LRU cache where the least recently used records are expired.
+     * The value is expressed as a percentage of the TTL sent on the most recent write such that a read
+     * within this interval of the record’s end of life will generate a touch.
+     *
+     * For example, if the most recent write had a TTL of 10 hours and read_touch_ttl_percent is set to
+     * 80, the next read within 8 hours of the record's end of life (equivalent to 2 hours after the most
+     * recent write) will result in a touch, resetting the TTL to another 10 hours.
+     *      *
+     * @type number
+     * @default 0
+     */
+    this.readTouchTtlPercent = props.readTouchTtlPercent
   }
 }
 

package/lib/policies/query_policy.js

@@ -95,6 +95,16 @@ class QueryPolicy extends BasePolicy {
      * @override
      */
     this.totalTimeout = props.totalTimeout
+
+    /**
+     * Expected query duration. The server treats the query in different ways depending on the expected duration.
+     * This field is ignored for aggregation queries, background queries and server versions < 6.0.
+     *
+     * @see {@link module:aerospike/policy.queryDuration} for supported policy values.
+     * @type {@link module:aerospike/policy.queryDuration}
+     * @default {@link module:aerospike/policy.queryDuration.LONG}
+     */
+    this.expectedDuration = props.expectedDuration
   }
 }
 

package/lib/policies/read_policy.js

@@ -68,6 +68,21 @@ class ReadPolicy extends BasePolicy {
      */
     this.readModeSC = props.readModeSC
 
+    /**
+     * Determine how record TTL (time to live) is affected on reads. When enabled, the server can
+     * efficiently operate as a read-based LRU cache where the least recently used records are expired.
+     * The value is expressed as a percentage of the TTL sent on the most recent write such that a read
+     * within this interval of the record’s end of life will generate a touch.
+     *
+     * For example, if the most recent write had a TTL of 10 hours and read_touch_ttl_percent is set to
+     * 80, the next read within 8 hours of the record's end of life (equivalent to 2 hours after the most
+     * recent write) will result in a touch, resetting the TTL to another 10 hours.
+     *      *
+     * @type number
+     * @default 0
+     */
+    this.readTouchTtlPercent = props.readTouchTtlPercent
+
     /**
      * Should CDT data types (Lists / Maps) be deserialized to JS data types
      * (Arrays / Objects) or returned as raw bytes (Buffer).

package/lib/policy.js

@@ -296,6 +296,36 @@ exports.readModeSC = as.policy.readModeSC
  */
 exports.commitLevel = as.policy.commitLevel
 
+/**
+ * @summary Expected query duration. The server treats the query in different ways depending on the expected duration.
+ * This enum is ignored for aggregation (UDF) queries, background queries and server versions < 6.0.
+ *
+ * @enum {number}
+ *
+ * @property {number} LONG - The query is expected to return more than 100 records per node. The server optimizes for a
+ * large record set in the following ways:
+ * <ul>
+ * <li>Allow query to be run in multiple threads using the server's query threading configuration.</li>
+ * <li>Do not relax read consistency for AP namespaces.</li>
+ * <li>Add the query to the server's query monitor.</li>
+ * <li>Do not add the overall latency to the server's latency histogram.</li>
+ * <li>Do not allow server timeouts.</li>
+ * </ul>
+ * @property {number} SHORT - The query is expected to return less than 100 records per node. The server optimizes for a
+ * small record set in the following ways:
+ * <ul>
+ * <li>Always run the query in one thread and ignore the server's query threading configuration.</li>
+ * <li>Allow query to be inlined directly on the server's service thread.</li>
+ * <li>Relax read consistency for AP namespaces.</li>
+ * <li>Do not add the query to the server's query monitor.</li>
+ * <li>Add the overall latency to the server's latency histogram.</li>
+ * <li>Allow server timeouts. The default server timeout for a short query is 1 second.</li>
+ * </ul>
+ * @property {number} LONG_RELAX_AP - Treat query as a LONG query, but relax read consistency for AP namespaces.
+ * This value is treated exactly like LONG for server versions &lt; 7.1.
+ */
+exports.queryDuration = as.queryDuration
+
 /**
  * A base class extended to client policies.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aerospike",
-  "version": "5.11.0",
+  "version": "5.12.0",
   "description": "Aerospike Client Library",
   "keywords": [
     "aerospike",
@@ -59,24 +59,24 @@
     "@mapbox/node-pre-gyp": "^1.0.11",
     "bindings": "^1.5.0",
     "minimatch": "^3.1.2",
-    "nan": "^2.18.0",
-    "node-gyp": "^10.0.1",
+    "nan": "^2.19.0",
+    "node-gyp": "^10.1.0",
     "npm-run-all": "^4.1.5"
   },
   "devDependencies": {
-    "@types/node": "^20.11.18",
-    "chai": "^4.3.7",
+    "@types/node": "^20.12.7",
+    "chai": "^4.4.1",
     "choma": "^1.2.1",
     "codecov": "^3.8.3",
     "deep-eql": "^4.1.3",
     "husky": "^9.0.11",
-    "mocha": "^10.3.0",
+    "mocha": "^10.4.0",
     "mocha-clean": "^1.0.0",
     "nyc": "^15.1.0",
     "p-throttle": "^3.1.0",
     "semver": "^7.6.0",
     "standard": "^17.1.0",
-    "tmp": "^0.2.1",
+    "tmp": "^0.2.3",
     "yargs": "^17.7.2"
   },
   "standard": {

package/src/include/enums.h

@@ -41,6 +41,7 @@ v8::Local<v8::Object> retry_policy_values();
 v8::Local<v8::Object> status();
 v8::Local<v8::Object> ttl_enum_values();
 v8::Local<v8::Object> batchTypes();
+v8::Local<v8::Object> queryDuration();
 v8::Local<v8::Object> privilegeCode();
 v8::Local<v8::Object> expReadFlags();
 v8::Local<v8::Object> expWriteFlags();

package/src/main/aerospike.cc

@@ -156,6 +156,7 @@ NAN_MODULE_INIT(Aerospike)
 	export("ttl", ttl_enum_values());
 	export("auth", auth_mode_enum_values());
 	export("batchTypes", batchTypes());
+	export("queryDuration", queryDuration());
 	export("privilegeCode", privilegeCode());
 	export("expReadFlags", expReadFlags());
 	export("expWriteFlags", expWriteFlags());

package/src/main/bit_operations.cc

@@ -254,7 +254,7 @@ bool add_bit_rshift_op(as_operations *ops, char *bin, as_bit_policy *policy,
 
 typedef bool (*AsBitMath)(as_operations *ops, const char *bin, as_cdt_ctx *ctx,
 						  as_bit_policy *policy, int bit_offset,
-						  uint32_t bit_size, int64_t value, bool sign,
+						  uint32_t bit_size, uint64_t value, bool sign,
 						  as_bit_overflow_action action);
 
 bool add_bit_math_op(as_operations *ops, AsBitMath math_op, char *bin,

package/src/main/enums/query_duration.cc

@@ -0,0 +1,38 @@
+/*******************************************************************************
+ * Copyright 2023 Aerospike, Inc.
+ *
+ * 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.
+ ******************************************************************************/
+
+#include <node.h>
+#include <nan.h>
+
+extern "C" {
+#include <aerospike/as_policy.h>
+}
+
+using namespace v8;
+
+#define set(__obj, __name, __value)                                            \
+	Nan::Set(__obj, Nan::New(__name).ToLocalChecked(), Nan::New(__value))
+
+Local<Object> queryDuration()
+{
+	Nan::EscapableHandleScope scope;
+	Local<Object> obj = Nan::New<Object>();
+	set(obj, "LONG", AS_QUERY_DURATION_LONG);
+	set(obj, "SHORT", AS_QUERY_DURATION_SHORT);
+	set(obj, "LONG_RELAX_AP", AS_QUERY_DURATION_LONG_RELAX_AP);
+
+	return scope.Escape(obj);
+}

package/src/main/policy.cc

@@ -130,6 +130,11 @@ int readpolicy_from_jsobject(as_policy_read *policy, Local<Object> obj,
 		AS_NODE_PARAM_OK) {
 		return rc;
 	}
+	if ((rc = get_optional_int_property((int *)&policy->read_touch_ttl_percent,
+										   NULL, obj, "readTouchTtlPercent", log)) !=
+		AS_NODE_PARAM_OK) {
+		return rc;
+	}
 	if ((rc = get_optional_bool_property(&policy->deserialize, NULL, obj,
 										 "deserialize", log)) !=
 		AS_NODE_PARAM_OK) {
@@ -249,6 +254,11 @@ int operatepolicy_from_jsobject(as_policy_operate *policy, Local<Object> obj,
 		AS_NODE_PARAM_OK) {
 		return rc;
 	}
+	if ((rc = get_optional_int_property((int *)&policy->read_touch_ttl_percent,
+										   NULL, obj, "readTouchTtlPercent", log)) !=
+		AS_NODE_PARAM_OK) {
+		return rc;
+	}
 	if ((rc = get_optional_uint32_property((uint32_t *)&policy->commit_level,
 										   NULL, obj, "commitLevel", log)) !=
 		AS_NODE_PARAM_OK) {
@@ -342,6 +352,11 @@ int batchpolicy_from_jsobject(as_policy_batch *policy, Local<Object> obj,
 		AS_NODE_PARAM_OK) {
 		return rc;
 	}
+	if ((rc = get_optional_int_property((int *)&policy->read_touch_ttl_percent,
+										   NULL, obj, "readTouchTtlPercent", log)) !=
+		AS_NODE_PARAM_OK) {
+		return rc;
+	}
 	if ((rc = get_optional_bool_property(&policy->concurrent, NULL, obj,
 										 "concurrent", log)) !=
 		AS_NODE_PARAM_OK) {
@@ -405,7 +420,11 @@ int batchread_policy_from_jsobject(as_policy_batch_read *policy,
 		AS_NODE_PARAM_OK) {
 		return rc;
 	}
-
+	if ((rc = get_optional_int_property((int *)&policy->read_touch_ttl_percent,
+										   NULL, obj, "readTouchTtlPercent", log)) !=
+		AS_NODE_PARAM_OK) {
+		return rc;
+	}
 	return rc;
 }
 
@@ -581,6 +600,11 @@ int querypolicy_from_jsobject(as_policy_query *policy, Local<Object> obj,
 		AS_NODE_PARAM_OK) {
 		return rc;
 	}
+	if ((rc = get_optional_uint32_property((uint32_t *)&policy->expected_duration, NULL, obj,
+										 "expectedDuration", log)) !=
+		AS_NODE_PARAM_OK) {
+		return rc;
+	}
 	if ((rc = get_optional_bool_property(&policy->fail_on_cluster_change, NULL, obj, "failOnClusterChange", log)) != AS_NODE_PARAM_OK) {
 		return rc;
 	}

package/test/batch_read.js

@@ -181,6 +181,185 @@ describe('client.batchRead()', function () {
           })
       })
     })
+
+    context('readTouchTtlPercent policy', function () {
+      let batch = [{
+        key: new Aerospike.Key('test', 'demo', 'batchReadTtl1'),
+        readAllBins: true
+      }]
+      this.timeout(4000)
+
+      context('BatchPolicy policy', function () {
+        helper.skipUnlessVersion('>= 7.1.0', this)
+
+        it('100% touches record', async function () {
+          const policy = new Aerospike.BatchReadPolicy({
+            readTouchTtlPercent: 100
+          })
+
+          await client.put(new Aerospike.Key('test', 'demo', 'batchReadTtl1'), { i: 2 }, { ttl: 10 })
+          await new Promise(resolve => setTimeout(resolve, 3000))
+
+          const batchResult = await client.batchRead(batch, policy)
+          expect(batchResult[0].record.bins).to.eql({ i: 2 })
+          expect(batchResult[0].record.ttl).to.be.within(7, 8)
+
+          const record = await client.get(new Aerospike.Key('test', 'demo', 'batchReadTtl1'))
+          expect(record.bins).to.eql({ i: 2 })
+          expect(record.ttl).to.be.within(9, 10)
+
+          await client.remove(new Aerospike.Key('test', 'demo', 'batchReadTtl1'))
+        })
+
+        it('71% touches record', async function () {
+          const policy = new Aerospike.BatchReadPolicy({
+            readTouchTtlPercent: 71
+          })
+
+          await client.put(new Aerospike.Key('test', 'demo', 'batchReadTtl1'), { i: 2 }, { ttl: 10 })
+          await new Promise(resolve => setTimeout(resolve, 3000))
+
+          const batchResult = await client.batchRead(batch, policy)
+          expect(batchResult[0].record.bins).to.eql({ i: 2 })
+          expect(batchResult[0].record.ttl).to.be.within(7, 8)
+
+          const record = await client.get(new Aerospike.Key('test', 'demo', 'batchReadTtl1'))
+          expect(record.bins).to.eql({ i: 2 })
+          expect(record.ttl).to.be.within(9, 10)
+
+          await client.remove(new Aerospike.Key('test', 'demo', 'batchReadTtl1'))
+        })
+
+        it('60% doesnt touch record', async function () {
+          const policy = new Aerospike.BatchReadPolicy({
+            readTouchTtlPercent: 60
+          })
+
+          await client.put(new Aerospike.Key('test', 'demo', 'batchReadTtl1'), { i: 2 }, { ttl: 10 })
+          await new Promise(resolve => setTimeout(resolve, 3000))
+
+          const batchResult = await client.batchRead(batch, policy)
+          expect(batchResult[0].record.bins).to.eql({ i: 2 })
+          expect(batchResult[0].record.ttl).to.be.within(7, 8)
+
+          const record = await client.get(new Aerospike.Key('test', 'demo', 'batchReadTtl1'))
+          expect(record.bins).to.eql({ i: 2 })
+          expect(record.ttl).to.be.within(7, 8)
+
+          await client.remove(new Aerospike.Key('test', 'demo', 'batchReadTtl1'))
+        })
+
+        it('0% doesnt touch record', async function () {
+          const policy = new Aerospike.BatchReadPolicy({
+            readTouchTtlPercent: 0
+          })
+
+          await client.put(new Aerospike.Key('test', 'demo', 'batchReadTtl1'), { i: 2 }, { ttl: 10 })
+          await new Promise(resolve => setTimeout(resolve, 3000))
+
+          const batchResult = await client.batchRead(batch, policy)
+          expect(batchResult[0].record.bins).to.eql({ i: 2 })
+          expect(batchResult[0].record.ttl).to.be.within(7, 8)
+
+          const record = await client.get(new Aerospike.Key('test', 'demo', 'batchReadTtl1'))
+          expect(record.bins).to.eql({ i: 2 })
+          expect(record.ttl).to.be.within(7, 8)
+
+          await client.remove(new Aerospike.Key('test', 'demo', 'batchReadTtl1'))
+        })
+      })
+
+      context('BatchReadPolicy policy', function () {
+        helper.skipUnlessVersion('>= 7.1.0', this)
+        it('100% touches record', async function () {
+          batch = [{
+            key: new Aerospike.Key('test', 'demo', 'batchReadTtl1'),
+            readAllBins: true,
+            policy: new Aerospike.BatchPolicy({
+              readTouchTtlPercent: 100
+            })
+          }]
+          await client.put(new Aerospike.Key('test', 'demo', 'batchReadTtl1'), { i: 2 }, { ttl: 10 })
+          await new Promise(resolve => setTimeout(resolve, 3000))
+
+          const batchResult = await client.batchRead(batch)
+          expect(batchResult[0].record.bins).to.eql({ i: 2 })
+          expect(batchResult[0].record.ttl).to.be.within(7, 8)
+
+          const record = await client.get(new Aerospike.Key('test', 'demo', 'batchReadTtl1'))
+          expect(record.bins).to.eql({ i: 2 })
+          expect(record.ttl).to.be.within(9, 10)
+
+          await client.remove(new Aerospike.Key('test', 'demo', 'batchReadTtl1'))
+        })
+
+        it('71% touches record', async function () {
+          batch = [{
+            key: new Aerospike.Key('test', 'demo', 'batchReadTtl1'),
+            readAllBins: true,
+            policy: new Aerospike.BatchPolicy({
+              readTouchTtlPercent: 71
+            })
+          }]
+          await client.put(new Aerospike.Key('test', 'demo', 'batchReadTtl1'), { i: 2 }, { ttl: 10 })
+          await new Promise(resolve => setTimeout(resolve, 3000))
+
+          const batchResult = await client.batchRead(batch)
+          expect(batchResult[0].record.bins).to.eql({ i: 2 })
+          expect(batchResult[0].record.ttl).to.be.within(7, 8)
+
+          const record = await client.get(new Aerospike.Key('test', 'demo', 'batchReadTtl1'))
+          expect(record.bins).to.eql({ i: 2 })
+          expect(record.ttl).to.be.within(9, 10)
+
+          await client.remove(new Aerospike.Key('test', 'demo', 'batchReadTtl1'))
+        })
+
+        it('60% doesnt touch record', async function () {
+          batch = [{
+            key: new Aerospike.Key('test', 'demo', 'batchReadTtl1'),
+            readAllBins: true,
+            policy: new Aerospike.BatchPolicy({
+              readTouchTtlPercent: 60
+            })
+          }]
+          await client.put(new Aerospike.Key('test', 'demo', 'batchReadTtl1'), { i: 2 }, { ttl: 10 })
+          await new Promise(resolve => setTimeout(resolve, 3000))
+
+          const batchResult = await client.batchRead(batch)
+          expect(batchResult[0].record.bins).to.eql({ i: 2 })
+          expect(batchResult[0].record.ttl).to.be.within(7, 8)
+
+          const record = await client.get(new Aerospike.Key('test', 'demo', 'batchReadTtl1'))
+          expect(record.bins).to.eql({ i: 2 })
+          expect(record.ttl).to.be.within(7, 8)
+
+          await client.remove(new Aerospike.Key('test', 'demo', 'batchReadTtl1'))
+        })
+
+        it('0% doesnt touch record', async function () {
+          batch = [{
+            key: new Aerospike.Key('test', 'demo', 'batchReadTtl1'),
+            readAllBins: true,
+            policy: new Aerospike.BatchPolicy({
+              readTouchTtlPercent: 0
+            })
+          }]
+          await client.put(new Aerospike.Key('test', 'demo', 'batchReadTtl1'), { i: 2 }, { ttl: 10 })
+          await new Promise(resolve => setTimeout(resolve, 3000))
+
+          const batchResult = await client.batchRead(batch)
+          expect(batchResult[0].record.bins).to.eql({ i: 2 })
+          expect(batchResult[0].record.ttl).to.be.within(7, 8)
+
+          const record = await client.get(new Aerospike.Key('test', 'demo', 'batchReadTtl1'))
+          expect(record.bins).to.eql({ i: 2 })
+          expect(record.ttl).to.be.within(7, 8)
+
+          await client.remove(new Aerospike.Key('test', 'demo', 'batchReadTtl1'))
+        })
+      })
+    })
   })
 
   it('returns a Promise that resolves to the batch results', function () {

package/test/get.js

@@ -82,6 +82,93 @@ describe('client.get()', function () {
           })
       })
     })
+
+    context('readTouchTtlPercent policy', function () {
+      helper.skipUnlessVersion('>= 7.1.0', this)
+
+      this.timeout(4000)
+      it('100% touches record', async function () {
+        const key = keygen.integer(helper.namespace, helper.set)()
+        const policy = new Aerospike.ReadPolicy({
+          readTouchTtlPercent: 100
+        })
+
+        await client.put(key, { i: 2 }, { ttl: 10 })
+        await new Promise(resolve => setTimeout(resolve, 3000))
+        let record = await client.get(key, policy)
+
+        expect(record.bins).to.eql({ i: 2 })
+        expect(record.ttl).to.be.within(7, 8)
+
+        record = await client.get(key, policy)
+
+        expect(record.bins).to.eql({ i: 2 })
+        expect(record.ttl).to.be.within(9, 10)
+
+        await client.remove(key)
+      })
+
+      it('71% touches record', async function () {
+        const key = keygen.integer(helper.namespace, helper.set)()
+        const policy = new Aerospike.ReadPolicy({
+          readTouchTtlPercent: 71
+        })
+
+        await client.put(key, { i: 2 }, { ttl: 10 })
+        await new Promise(resolve => setTimeout(resolve, 3000))
+        let record = await client.get(key, policy)
+
+        expect(record.bins).to.eql({ i: 2 })
+        expect(record.ttl).to.be.within(7, 8)
+
+        record = await client.get(key, policy)
+
+        expect(record.bins).to.eql({ i: 2 })
+        expect(record.ttl).to.be.within(9, 10)
+
+        await client.remove(key)
+      })
+
+      it('60% never touches record', async function () {
+        const key = keygen.integer(helper.namespace, helper.set)()
+        const policy = new Aerospike.ReadPolicy({
+          readTouchTtlPercent: 60
+        })
+        await client.put(key, { i: 2 }, { ttl: 10 })
+        await new Promise(resolve => setTimeout(resolve, 3000))
+
+        let record = await client.get(key, policy)
+
+        expect(record.bins).to.eql({ i: 2 })
+        expect(record.ttl).to.be.within(7, 8)
+
+        record = await client.get(key, policy)
+
+        expect(record.bins).to.eql({ i: 2 })
+        expect(record.ttl).to.be.within(7, 8)
+        await client.remove(key)
+      })
+
+      it('0% never touches record', async function () {
+        const key = keygen.integer(helper.namespace, helper.set)()
+        const policy = new Aerospike.ReadPolicy({
+          readTouchTtlPercent: 0
+        })
+        await client.put(key, { i: 2 }, { ttl: 10 })
+        await new Promise(resolve => setTimeout(resolve, 3000))
+
+        let record = await client.get(key, policy)
+
+        expect(record.bins).to.eql({ i: 2 })
+        expect(record.ttl).to.be.within(7, 8)
+
+        record = await client.get(key, policy)
+
+        expect(record.bins).to.eql({ i: 2 })
+        expect(record.ttl).to.be.within(7, 8)
+        await client.remove(key)
+      })
+    })
   })
 
   it('should return the TTL for a never expiring record as Aerospike.ttl.NEVER_EXPIRE', function (done) {

package/test/operate.js

@@ -281,6 +281,91 @@ context('Operations', function () {
         })
       })
 
+      context('readTouchTtlPercent policy', function () {
+        helper.skipUnlessVersion('>= 7.1.0', this)
+
+        this.timeout(4000)
+        it('100% touches record', async function () {
+          const ops = [op.read('i')]
+          const policy = new Aerospike.OperatePolicy({
+            readTouchTtlPercent: 100
+          })
+
+          await client.put(new Aerospike.Key('test', 'demo', 'operateTtl1'), { i: 2 }, { ttl: 10 })
+          await new Promise(resolve => setTimeout(resolve, 3000))
+
+          let record = await client.operate(new Aerospike.Key('test', 'demo', 'operateTtl1'), ops, null, policy)
+          expect(record.bins).to.eql({ i: 2 })
+          expect(record.ttl).to.be.within(7, 8)
+
+          record = await client.get(new Aerospike.Key('test', 'demo', 'operateTtl1'), policy)
+          expect(record.bins).to.eql({ i: 2 })
+          expect(record.ttl).to.be.within(9, 10)
+
+          await client.remove(new Aerospike.Key('test', 'demo', 'operateTtl1'))
+        })
+
+        it('71% touches record', async function () {
+          const ops = [op.read('i')]
+          const policy = new Aerospike.OperatePolicy({
+            readTouchTtlPercent: 71
+          })
+
+          await client.put(new Aerospike.Key('test', 'demo', 'operateTtl1'), { i: 2 }, { ttl: 10 })
+          await new Promise(resolve => setTimeout(resolve, 3000))
+
+          let record = await client.operate(new Aerospike.Key('test', 'demo', 'operateTtl1'), ops, null, policy)
+          expect(record.bins).to.eql({ i: 2 })
+          expect(record.ttl).to.be.within(7, 8)
+
+          record = await client.get(new Aerospike.Key('test', 'demo', 'operateTtl1'), policy)
+          expect(record.bins).to.eql({ i: 2 })
+          expect(record.ttl).to.be.within(9, 10)
+
+          await client.remove(new Aerospike.Key('test', 'demo', 'operateTtl1'))
+        })
+
+        it('60% does not touch record', async function () {
+          const ops = [op.read('i')]
+          const policy = new Aerospike.OperatePolicy({
+            readTouchTtlPercent: 60
+          })
+
+          await client.put(new Aerospike.Key('test', 'demo', 'operateTtl1'), { i: 2 }, { ttl: 10 })
+          await new Promise(resolve => setTimeout(resolve, 3000))
+
+          let record = await client.operate(new Aerospike.Key('test', 'demo', 'operateTtl1'), ops, null, policy)
+          expect(record.bins).to.eql({ i: 2 })
+          expect(record.ttl).to.be.within(7, 8)
+
+          record = await client.get(new Aerospike.Key('test', 'demo', 'operateTtl1'), policy)
+          expect(record.bins).to.eql({ i: 2 })
+          expect(record.ttl).to.be.within(7, 8)
+
+          await client.remove(new Aerospike.Key('test', 'demo', 'operateTtl1'))
+        })
+
+        it('0% does not touch record', async function () {
+          const ops = [op.read('i')]
+          const policy = new Aerospike.OperatePolicy({
+            readTouchTtlPercent: 0
+          })
+
+          await client.put(new Aerospike.Key('test', 'demo', 'operateTtl1'), { i: 2 }, { ttl: 10 })
+          await new Promise(resolve => setTimeout(resolve, 3000))
+
+          let record = await client.operate(new Aerospike.Key('test', 'demo', 'operateTtl1'), ops, null, policy)
+          expect(record.bins).to.eql({ i: 2 })
+          expect(record.ttl).to.be.within(7, 8)
+
+          record = await client.get(new Aerospike.Key('test', 'demo', 'operateTtl1'), policy)
+          expect(record.bins).to.eql({ i: 2 })
+          expect(record.ttl).to.be.within(7, 8)
+
+          await client.remove(new Aerospike.Key('test', 'demo', 'operateTtl1'))
+        })
+      })
+
       context('gen policy', function () {
         context('policy.gen.EQ', function () {
           const policy = new Aerospike.OperatePolicy({

package/test/query.js

@@ -273,6 +273,45 @@ describe('Queries', function () {
         done()
       })
     })
+    context('expectedDuration', function () {
+      helper.skipUnlessVersion('>= 7.1.0', this)
+
+      it('Should run a regular primary index query with expectedDuration=LONG', function (done) {
+        const query = client.query(helper.namespace, testSet)
+        const stream = query.foreach({ expectedDuration: Aerospike.policy.queryDuration.LONG })
+        const results = []
+        stream.on('error', error => { throw error })
+        stream.on('data', record => results.push(record.bins))
+        stream.on('end', () => {
+          expect(results.length).to.be.above(samples.length)
+          done()
+        })
+      })
+
+      it('Should run a regular primary index query with expectedDuration=SHORT', function (done) {
+        const query = client.query(helper.namespace, testSet)
+        const stream = query.foreach({ expectedDuration: Aerospike.policy.queryDuration.SHORT })
+        const results = []
+        stream.on('error', error => { throw error })
+        stream.on('data', record => results.push(record.bins))
+        stream.on('end', () => {
+          expect(results.length).to.be.above(samples.length)
+          done()
+        })
+      })
+
+      it('Should run a regular primary index query with expectedDuration=LONG_RELAX_AP', function (done) {
+        const query = client.query(helper.namespace, testSet)
+        const stream = query.foreach({ expectedDuration: Aerospike.policy.queryDuration.LONG_RELAX_AP })
+        const results = []
+        stream.on('error', error => { throw error })
+        stream.on('data', record => results.push(record.bins))
+        stream.on('end', () => {
+          expect(results.length).to.be.above(samples.length)
+          done()
+        })
+      })
+    })
 
     it('Should run a paginated primary index query', async function () {
       let recordTotal = 0

package/typings/index.d.ts

@@ -1504,6 +1504,7 @@ declare module 'policies/query_policy' {
       deserialize: boolean;
       failOnClusterChange: boolean;
       infoTimeout: number;
+      expectedDuration: number;
   }
   import BasePolicy = require("policies/base_policy");
 
@@ -1653,6 +1654,11 @@ declare module 'query' {
   import RecordStream = require("record_stream");
 
 }
+declare module 'query_duration' {
+  export const LONG: any;
+  export const SHORT: any;
+  export const LONG_RELAX_AP: any;
+}
 declare module 'record' {
   export = Record;
   class Record {