From b0bb77637d797f9442c5aa4a484c45affdf697ab Mon Sep 17 00:00:00 2001
From: Keijo Kapp <keijo.kapp@gmail.com>
Date: Fri, 10 May 2024 12:54:09 +0300
Subject: [PATCH] Added support for including keyspace ends in the ranges

---
 lib/database.ts          |  23 ++-
 lib/directory.ts         |   2 +-
 lib/subspace.ts          |  93 ++++++++++--
 lib/transaction.ts       | 310 ++++++++++++++++++++++-----------------
 scripts/bindingtester.ts |   2 +-
 5 files changed, 276 insertions(+), 154 deletions(-)

diff --git a/lib/database.ts b/lib/database.ts
index 41afec6..f24b24f 100644
--- a/lib/database.ts
+++ b/lib/database.ts
@@ -22,6 +22,15 @@ export default class Database<KeyIn = NativeValue, KeyOut = Buffer, ValIn = Nati
     this.subspace = subspace//new Subspace<KeyIn, KeyOut, ValIn, ValOut>(prefix, keyXf, valueXf)
   }
 
+  /**
+   * Switch to a new mode of handling ranges.
+   *
+   * @see Subspace.noDefaultPrefix
+   */
+  noDefaultPrefix() {
+    return new Database(this._db, this.subspace.noDefaultPrefix())
+  }
+
   setNativeOptions(opts: DatabaseOptions) {
     eachOption(databaseOptionData, opts, (code, val) => this._db.setOption(code, val))
   }
@@ -108,7 +117,7 @@ export default class Database<KeyIn = NativeValue, KeyOut = Buffer, ValIn = Nati
     return this.doOneshot(tn => tn.clear(key))
   }
 
-  clearRange(start: KeyIn, end?: KeyIn) {
+  clearRange(start?: KeyIn, end?: KeyIn) {
     return this.doOneshot(tn => tn.clearRange(start, end))
   }
 
@@ -144,21 +153,21 @@ export default class Database<KeyIn = NativeValue, KeyOut = Buffer, ValIn = Nati
   }
 
   getRangeAll(
-      start: KeyIn | KeySelector<KeyIn>,
-      end?: KeyIn | KeySelector<KeyIn>,
+      start?: KeyIn | KeySelector<undefined | KeyIn>,
+      end?: KeyIn | KeySelector<undefined | KeyIn>,
       opts?: RangeOptions) {
-    return this.doTransaction(async tn => tn.snapshot().getRangeAll(start, end, opts))
+    return this.doTransaction(tn => tn.snapshot().getRangeAll(start, end, opts))
   }
 
   getRangeAllStartsWith(prefix: KeyIn | KeySelector<KeyIn>, opts?: RangeOptions) {
-    return this.getRangeAll(prefix, undefined, opts)
+    return this.doTransaction(tn => tn.snapshot().getRangeAllStartsWith(prefix, opts))
   }
 
-  getEstimatedRangeSizeBytes(start: KeyIn, end: KeyIn): Promise<number> {
+  getEstimatedRangeSizeBytes(start?: KeyIn, end?: KeyIn): Promise<number> {
     return this.doTransaction(tn => tn.getEstimatedRangeSizeBytes(start, end))
   }
 
-  getRangeSplitPoints(start: KeyIn, end: KeyIn, chunkSize: number): Promise<KeyOut[]> {
+  getRangeSplitPoints(start: KeyIn | undefined, end: KeyIn | undefined, chunkSize: number): Promise<KeyOut[]> {
     return this.doTransaction(tn => tn.getRangeSplitPoints(start, end, chunkSize))
   }
 
diff --git a/lib/directory.ts b/lib/directory.ts
index 92d7465..0f4bd79 100644
--- a/lib/directory.ts
+++ b/lib/directory.ts
@@ -917,7 +917,7 @@ export class DirectoryLayer {
 
   private async* _subdirNamesAndNodes(txn: TxnAny, node: NodeSubspace) {
     // TODO: This could work using async iterators to improve performance of searches on very large directories.
-    for await (const [key, prefix] of txn.at(node).getRange(SUBDIRS_KEY)) {
+    for await (const [key, prefix] of txn.at(node).getRangeStartsWith(SUBDIRS_KEY)) {
       yield [key[1], this._nodeWithPrefix(prefix)] as [Buffer, NodeSubspace]
     }
   }
diff --git a/lib/subspace.ts b/lib/subspace.ts
index eb52e0c..4a1d185 100644
--- a/lib/subspace.ts
+++ b/lib/subspace.ts
@@ -5,7 +5,10 @@
 
 import { Transformer, prefixTransformer, defaultTransformer, defaultGetRange } from "./transformer"
 import { NativeValue } from "./native"
-import { asBuf, concat2, startsWith } from "./util"
+import {
+  asBuf, concat2, startsWith, strInc
+} from "./util"
+import { UnboundStamp } from './versionstamp.js'
 
 const EMPTY_BUF = Buffer.alloc(0)
 
@@ -26,7 +29,14 @@ export default class Subspace<KeyIn = NativeValue, KeyOut = Buffer, ValIn = Nati
 
   _bakedKeyXf: Transformer<KeyIn, KeyOut> // This is cached from _prefix + keyXf.
 
-  constructor(rawPrefix: string | Buffer | null, keyXf?: Transformer<KeyIn, KeyOut>, valueXf?: Transformer<ValIn, ValOut>) {
+  _noDefaultPrefix: boolean
+
+  constructor(
+    rawPrefix: string | Buffer | null,
+    keyXf?: Transformer<KeyIn, KeyOut>,
+    valueXf?: Transformer<ValIn, ValOut>,
+    noDefaultPrefix: boolean = false
+  ) {
     this.prefix = rawPrefix != null ? Buffer.from(rawPrefix) : EMPTY_BUF
 
     // Ugh typing this is a mess. Usually this will be fine since if you say new
@@ -35,6 +45,24 @@ export default class Subspace<KeyIn = NativeValue, KeyOut = Buffer, ValIn = Nati
     this.valueXf = valueXf || (defaultTransformer as Transformer<any, any>)
 
     this._bakedKeyXf = rawPrefix ? prefixTransformer(rawPrefix, this.keyXf) : this.keyXf
+
+    this._noDefaultPrefix = noDefaultPrefix
+  }
+
+  /**
+   * Switch to a new mode of handling ranges. By default, the range operations (`getRange` family
+   * and `clearRange`) treat calls with missing end key as operations on prefix ranges. That means
+   * that a call like `tn.at('a').getRange('x')` acts on prefix `ax`, ie key range `[ax, ay)`. In
+   * the new mode, the missing end key defaults to a subspace end (inclusive), ie that call would
+   * act on a range `[ax, b)`. This enabled specifying key ranges not possible before.
+   *
+   * To specifiy range as a prefix, use `StartsWith` version of those methods (eg
+   * `getRangeAllStartsWith`).
+   *
+   * @see Subspace.packRange
+   */
+  noDefaultPrefix() {
+    return new Subspace(this.prefix, this.keyXf, this.valueXf, true)
   }
 
   // All these template parameters make me question my life choices, but this is
@@ -48,21 +76,21 @@ export default class Subspace<KeyIn = NativeValue, KeyOut = Buffer, ValIn = Nati
   // ***
   at(prefix: KeyIn | null, keyXf: Transformer<any, any> = this.keyXf, valueXf: Transformer<any, any> = this.valueXf) {
     const _prefix = prefix == null ? null : this.keyXf.pack(prefix)
-    return new Subspace(concatPrefix(this.prefix, _prefix), keyXf, valueXf)
+    return new Subspace(concatPrefix(this.prefix, _prefix), keyXf, valueXf, this._noDefaultPrefix)
   }
 
   /** At a child prefix thats specified without reference to the key transformer */
   atRaw(prefix: Buffer) {
-    return new Subspace(concatPrefix(this.prefix, prefix), this.keyXf, this.valueXf)
+    return new Subspace(concatPrefix(this.prefix, prefix), this.keyXf, this.valueXf, this._noDefaultPrefix)
   }
 
 
   withKeyEncoding<CKI, CKO>(keyXf: Transformer<CKI, CKO>): Subspace<CKI, CKO, ValIn, ValOut> {
-    return new Subspace(this.prefix, keyXf, this.valueXf)
+    return new Subspace(this.prefix, keyXf, this.valueXf, this._noDefaultPrefix)
   }
   
   withValueEncoding<CVI, CVO>(valXf: Transformer<CVI, CVO>): Subspace<KeyIn, KeyOut, CVI, CVO> {
-    return new Subspace(this.prefix, this.keyXf, valXf)
+    return new Subspace(this.prefix, this.keyXf, valXf, this._noDefaultPrefix)
   }
 
   // GetSubspace implementation
@@ -75,17 +103,62 @@ export default class Subspace<KeyIn = NativeValue, KeyOut = Buffer, ValIn = Nati
   unpackKey(key: Buffer): KeyOut {
     return this._bakedKeyXf.unpack(key)
   }
+  packKeyUnboundVersionstamp(key: KeyIn): UnboundStamp {
+    if (!this.keyXf.packUnboundVersionstamp) {
+      throw TypeError('Value encoding does not support unbound versionstamps. Use setVersionstampPrefixedValue instead')
+    }
+
+    return this.keyXf.packUnboundVersionstamp(key)
+  }
   packValue(val: ValIn): NativeValue {
     return this.valueXf.pack(val)
   }
   unpackValue(val: Buffer): ValOut {
     return this.valueXf.unpack(val)
   }
+  packValueUnboundVersionstamp(value: ValIn): UnboundStamp {
+    if (!this.valueXf.packUnboundVersionstamp) {
+      throw TypeError('Value encoding does not support unbound versionstamps. Use setVersionstampPrefixedValue instead')
+    }
+
+    return this.valueXf.packUnboundVersionstamp(value)
+  }
+
+  /**
+   * Encodes a range specified by `start`/`end` pair using configured key encoder.
+   *
+   * @param start Start of the key range. If undefined, the start of the subspace is assumed.
+   * @param end Start of the key range. If undefined, the end of the subspace is assumed, unless
+   * `noDefaultPrefix` flag is set or enabled for this subspace, in which case, start key is treated
+   * as a prefix.
+   * @param noDefaultPrefix Disable treating start key as a prefix if end key is not specified.
+   * @returns Encoded range as a `{ begin, end }` record.
+   */
+  packRange(
+    start?: KeyIn,
+    end?: KeyIn,
+    noDefaultPrefix: boolean = false
+  ): {begin: NativeValue, end: NativeValue} {
+    if (start !== undefined && end === undefined && !this._noDefaultPrefix && !noDefaultPrefix) {
+      return this.packRangeStartsWith(start)
+    }
+
+    return {
+      begin: start !== undefined ? this._bakedKeyXf.pack(start) : this.prefix,
+      end: end !== undefined ? this._bakedKeyXf.pack(end) : strInc(this.prefix)
+    }
+  }
+
+  /**
+   * Encodes a range specified by the prefix using configured key encoder.
+   *
+   * @param start Start of the key key range. If undefined, the start of the subspace is assumed.
+   * @returns Encoded range as a `{ begin, end }` record.
+   */
+  packRangeStartsWith(prefix: KeyIn): {begin: NativeValue, end: NativeValue} {
+    const encodePrefix = this._bakedKeyXf.range ?? defaultGetRange
 
-  packRange(prefix: KeyIn): {begin: NativeValue, end: NativeValue} {
-    // if (this._bakedKeyXf.range) return this._bakedKeyXf.range(prefix)
-    // else return defaultGetRange(prefix, this._bakedKeyXf)
-    return (this._bakedKeyXf.range || defaultGetRange)(prefix, this._bakedKeyXf)
+    return encodePrefix(prefix, this._bakedKeyXf)
   }
 
   contains(key: NativeValue) {
diff --git a/lib/transaction.ts b/lib/transaction.ts
index 543b910..0e70561 100644
--- a/lib/transaction.ts
+++ b/lib/transaction.ts
@@ -123,11 +123,6 @@ export default class Transaction<KeyIn = NativeValue, KeyOut = Buffer, ValIn = N
   isSnapshot: boolean
   subspace: Subspace<KeyIn, KeyOut, ValIn, ValOut>
 
-  // Copied out from scope for convenience, since these are so heavily used. Not
-  // sure if this is a good idea.
-  private _keyEncoding: Transformer<KeyIn, KeyOut>
-  private _valueEncoding: Transformer<ValIn, ValOut>
-  
   private _ctx: TxnCtx
   
   /**
@@ -144,8 +139,6 @@ export default class Transaction<KeyIn = NativeValue, KeyOut = Buffer, ValIn = N
 
     this.isSnapshot = snapshot
     this.subspace = subspace
-    this._keyEncoding = subspace._bakedKeyXf
-    this._valueEncoding = subspace.valueXf
 
     // this._root = root || this
     if (opts) eachOption(transactionOptionData, opts, (code, val) => tn.setOption(code, val))
@@ -266,20 +259,20 @@ export default class Transaction<KeyIn = NativeValue, KeyOut = Buffer, ValIn = N
   /** @deprecated - Use promises API instead. */
   get(key: KeyIn, cb: Callback<ValOut | undefined>): void
   get(key: KeyIn, cb?: Callback<ValOut | undefined>) {
-    const keyBuf = this._keyEncoding.pack(key)
+    const keyBuf = this.subspace.packKey(key)
     return cb
       ? this._tn.get(keyBuf, this.isSnapshot, (err, val) => {
-        cb(err, val == null ? undefined : this._valueEncoding.unpack(val))
+        cb(err, val == null ? undefined : this.subspace.unpackValue(val))
       })
       : this._tn.get(keyBuf, this.isSnapshot)
-        .then(val => val == null ? undefined : this._valueEncoding.unpack(val))
+        .then(val => val == null ? undefined : this.subspace.unpackValue(val))
   }
 
   /** Checks if the key exists in the database. This is just a shorthand for
    * tn.get() !== undefined.
    */
   exists(key: KeyIn): Promise<boolean> {
-    const keyBuf = this._keyEncoding.pack(key)
+    const keyBuf = this.subspace.packKey(key)
     return this._tn.get(keyBuf, this.isSnapshot).then(val => val != undefined)
   }
 
@@ -302,22 +295,22 @@ export default class Transaction<KeyIn = NativeValue, KeyOut = Buffer, ValIn = N
    */
   getKey(_sel: KeySelector<KeyIn> | KeyIn): Promise<KeyOut | undefined> {
     const sel = keySelector.from(_sel)
-    return this._tn.getKey(this._keyEncoding.pack(sel.key), sel.orEqual, sel.offset, this.isSnapshot)
+    return this._tn.getKey(this.subspace.packKey(sel.key), sel.orEqual, sel.offset, this.isSnapshot)
       .then(key => (
         (key.length === 0 || !this.subspace.contains(key))
           ? undefined
-          : this._keyEncoding.unpack(key)
+          : this.subspace.unpackKey(key)
       ))
   }
 
   /** Set the specified key/value pair in the database */
   set(key: KeyIn, val: ValIn) {
-    this._tn.set(this._keyEncoding.pack(key), this._valueEncoding.pack(val))
+    this._tn.set(this.subspace.packKey(key), this.subspace.packValue(val))
   }
 
   /** Remove the value for the specified key */
   clear(key: KeyIn) {
-    const pack = this._keyEncoding.pack(key)
+    const pack = this.subspace.packKey(key)
     this._tn.clear(pack)
   }
 
@@ -330,8 +323,8 @@ export default class Transaction<KeyIn = NativeValue, KeyOut = Buffer, ValIn = N
   private _encodeRangeResult(r: [Buffer, Buffer][]): [KeyOut, ValOut][] {
     // This is slightly faster but I have to throw away the TS checks in the process. :/
     for (let i = 0; i < r.length; i++) {
-      ;(r as any)[i][0] = this._keyEncoding.unpack(r[i][0])
-      ;(r as any)[i][1] = this._valueEncoding.unpack(r[i][1])
+      ;(r as any)[i][0] = this.subspace.unpackKey(r[i][0])
+      ;(r as any)[i][1] = this.subspace.unpackValue(r[i][1])
     }
     return r as any as [KeyOut, ValOut][]
   }
@@ -352,29 +345,64 @@ export default class Transaction<KeyIn = NativeValue, KeyOut = Buffer, ValIn = N
       limit: number, targetBytes: number, streamingMode: StreamingMode,
       iter: number, reverse: boolean): Promise<KVList<KeyOut, ValOut>> {
     return this.getRangeNative(
-      keySelector.toNative(start, this._keyEncoding),
-      end != null ? keySelector.toNative(end, this._keyEncoding) : null,
+      keySelector(this.subspace.packKey(start.key), start.orEqual, start.offset),
+      end != null ? keySelector(this.subspace.packKey(end.key), end.orEqual, end.offset) : null,
       limit, targetBytes, streamingMode, iter, reverse)
     .then(r => ({more: r.more, results: this._encodeRangeResult(r.results)}))
   }
 
-  getEstimatedRangeSizeBytes(start: KeyIn, end: KeyIn): Promise<number> {
-    return this._tn.getEstimatedRangeSizeBytes(
-      this._keyEncoding.pack(start),
-      this._keyEncoding.pack(end)
-    )
+  getEstimatedRangeSizeBytes(start?: KeyIn, end?: KeyIn): Promise<number> {
+    const range = this.subspace.packRange(start, end, true)
+
+    return this._tn.getEstimatedRangeSizeBytes(range.begin, range.end)
   }
 
-  getRangeSplitPoints(start: KeyIn, end: KeyIn, chunkSize: number): Promise<KeyOut[]> {
-    return this._tn.getRangeSplitPoints(
-      this._keyEncoding.pack(start),
-      this._keyEncoding.pack(end),
-      chunkSize
-    ).then(results => (
-      results.map(r => this._keyEncoding.unpack(r))
+  getRangeSplitPoints(start: KeyIn | undefined, end: KeyIn | undefined, chunkSize: number): Promise<KeyOut[]> {
+    const range = this.subspace.packRange(start, end, true)
+
+    return this._tn.getRangeSplitPoints(range.begin, range.end, chunkSize).then(results => (
+      results.map(r => this.subspace.unpackKey(r))
     ))
   }
 
+  async *getRangeBatchNative(
+    start: KeySelector<NativeValue>,
+    end: KeySelector<NativeValue>,
+    {
+      limit = 0,
+      reverse = false,
+      streamingMode = StreamingMode.Iterator
+    }: RangeOptions = {}
+  ) {
+    let iter = 0
+
+    while (1) {
+      const { results, more } = await this.getRangeNative(
+        start,
+        end,
+        limit,
+        0,
+        streamingMode,
+        ++iter,
+        reverse
+      )
+
+      if (results.length) {
+        if (!reverse) start = keySelector.firstGreaterThan(results[results.length-1][0])
+        else end = keySelector.firstGreaterOrEqual(results[results.length-1][0])
+      }
+
+      // This destructively consumes results.
+      yield this._encodeRangeResult(results)
+      if (!more) break
+
+      if (limit) {
+        limit -= results.length
+        if (limit <= 0) break
+      }
+    }
+  }
+
   /**
    * This method is functionally the same as *getRange*, but values are returned
    * in the batches they're delivered in from the database. This method is
@@ -393,54 +421,37 @@ export default class Transaction<KeyIn = NativeValue, KeyOut = Buffer, ValIn = N
    * 
    * @see Transaction.getRange
    */
-  async *getRangeBatch(
-      _start: KeyIn | KeySelector<KeyIn>, // Consider also supporting string / buffers for these.
-      _end?: KeyIn | KeySelector<KeyIn>, // If not specified, start is used as a prefix.
+  getRangeBatch(
+      start?: KeyIn | KeySelector<undefined | KeyIn>,
+      end?: KeyIn | KeySelector<undefined | KeyIn>,
       opts: RangeOptions = {}) {
-
-    // This is a bit of a dog's breakfast. We're trying to handle a lot of different cases here:
-    // - The start and end parameters can be specified as keys or as selectors
-    // - The end parameter can be missing / null, and if it is we want to "do the right thing" here
-    //   - Which normally means searching between [start, strInc(start)]
-    //   - But with tuple encoding this means between [start + '\x00', start + '\xff']
-
-    let start: KeySelector<string | Buffer>, end: KeySelector<string | Buffer>
-    const startSelEnc = keySelector.from(_start)
-    
-    if (_end == null) {
-      const range = this.subspace.packRange(startSelEnc.key)
-      start = keySelector(range.begin, startSelEnc.orEqual, startSelEnc.offset)
-      end = keySelector.firstGreaterOrEqual(range.end)
-    } else {
-      start = keySelector.toNative(startSelEnc, this._keyEncoding)
-      end = keySelector.toNative(keySelector.from(_end), this._keyEncoding)
-    }
-
-    let limit = opts.limit || 0
-    const streamingMode = opts.streamingMode == null ? StreamingMode.Iterator : opts.streamingMode
-
-    let iter = 0
-    while (1) {
-      const {results, more} = await this.getRangeNative(start, end,
-        limit, 0, streamingMode, ++iter, opts.reverse || false)
-
-      if (results.length) {
-        if (!opts.reverse) start = keySelector.firstGreaterThan(results[results.length-1][0])
-        else end = keySelector.firstGreaterOrEqual(results[results.length-1][0])
-      }
-
-      // This destructively consumes results.
-      yield this._encodeRangeResult(results)
-      if (!more) break
-
-      if (limit) {
-        limit -= results.length
-        if (limit <= 0) break
-      }
-    }
+    const startSelector = keySelector.from(start)
+    const endSelector = keySelector.from(end)
+    const range = this.subspace.packRange(startSelector.key, endSelector.key)
+
+    return this.getRangeBatchNative(
+      keySelector(range.begin, startSelector.orEqual, startSelector.offset),
+      keySelector(range.end, startSelector.orEqual, startSelector.offset),
+      opts
+    )
   }
 
-  // TODO: getRangeBatchStartsWith
+  /**
+   * This method is similar to *getRangeBatch*, but performs a query
+   * on a key range specified by `prefix` instead of start and end.
+   *
+   * @see Transaction.getRangeBatch
+   */
+  getRangeBatchStartsWith(prefix: KeyIn | KeySelector<KeyIn>, opts?: RangeOptions) {
+    const prefixSelector = keySelector.from(prefix)
+    const range = this.subspace.packRangeStartsWith(prefixSelector.key)
+
+    return this.getRangeBatchNative(
+      keySelector(range.begin, prefixSelector.orEqual, prefixSelector.offset),
+      keySelector.firstGreaterOrEqual(range.end),
+      opts
+    )
+  }
 
   /**
    * Get all key value pairs within the specified range. This method returns an
@@ -483,15 +494,27 @@ export default class Transaction<KeyIn = NativeValue, KeyOut = Buffer, ValIn = N
    *   opts.
    */
   async *getRange(
-      start: KeyIn | KeySelector<KeyIn>, // Consider also supporting string / buffers for these.
-      end?: KeyIn | KeySelector<KeyIn>,
+      start?: KeyIn | KeySelector<undefined | KeyIn>,
+      end?: KeyIn | KeySelector<undefined | KeyIn>,
       opts?: RangeOptions) {
     for await (const batch of this.getRangeBatch(start, end, opts)) {
       for (const pair of batch) yield pair
     }
   }
 
-  // TODO: getRangeStartsWtih
+  /**
+   * This method is similar to *getRange*, but performs a query
+   * on a key range specified by `prefix` instead of start and end.
+   *
+   * @see Transaction.getRange
+   */
+  async *getRangeStartsWith(
+      prefix: KeyIn | KeySelector<KeyIn>,
+      opts: RangeOptions = {}) {
+    for await (const batch of this.getRangeBatchStartsWith(prefix, opts)) {
+      for (const pair of batch) yield pair
+    }
+  }
 
   /**
    * Same as getRange, but prefetches and returns all values in an array rather
@@ -503,71 +526,97 @@ export default class Transaction<KeyIn = NativeValue, KeyOut = Buffer, ValIn = N
    * @returns array of [key, value] pairs
    */
   async getRangeAll(
-      start: KeyIn | KeySelector<KeyIn>,
-      end?: KeyIn | KeySelector<KeyIn>, // if undefined, start is used as a prefix.
-      opts: RangeOptions = {}) {
-    const childOpts: RangeOptions = {...opts}
-    if (childOpts.streamingMode == null) childOpts.streamingMode = StreamingMode.WantAll
+      start?: KeyIn | KeySelector<undefined | KeyIn>,
+      end?: KeyIn | KeySelector<undefined | KeyIn>,
+      opts?: RangeOptions) {
+    const childOpts: RangeOptions = opts?.streamingMode == null
+      ? { ...opts, streamingMode: StreamingMode.WantAll }
+      : opts
 
     const result: [KeyOut, ValOut][] = []
+
     for await (const batch of this.getRangeBatch(start, end, childOpts)) {
-      result.push.apply(result, batch)
+      result.push(...batch)
     }
+
     return result
   }
 
-  getRangeAllStartsWith(prefix: KeyIn | KeySelector<KeyIn>, opts?: RangeOptions) {
-    return this.getRangeAll(prefix, undefined, opts)
+  /**
+   * This method is similar to *getRangeAll*, but performs a query
+   * on a key range specified by `prefix` instead of start and end.
+   *
+   * @see Transaction.getRangeAll
+   */
+  async getRangeAllStartsWith(prefix: KeyIn | KeySelector<KeyIn>, opts?: RangeOptions) {
+    const childOpts: RangeOptions = opts?.streamingMode == null
+      ? { ...opts, streamingMode: StreamingMode.WantAll }
+      : opts
+
+    const result: [KeyOut, ValOut][] = []
+
+    for await (const batch of this.getRangeBatchStartsWith(prefix, childOpts)) {
+      result.push(...batch)
+    }
+
+    return result
   }
   
   /**
    * Removes all key value pairs from the database in between start and end.
    *
-   * End parameter is optional. If not specified, this removes all keys with
-   * *start* as a prefix.
+   * @param start Start of the range. If unspecified, the start of the keyspace is assumed.
+   * @param end End of the range. If unspecified, the inclusive end of the keyspace is assumed.
    */
-  clearRange(_start: KeyIn, _end?: KeyIn) {
-    let start: NativeValue, end: NativeValue
-    // const _start = this._keyEncoding.pack(start)
-
-    if (_end == null) {
-      const range = this.subspace.packRange(_start)
-      start = range.begin
-      end = range.end
-    } else {
-      start = this._keyEncoding.pack(_start)
-      end = this._keyEncoding.pack(_end)
-    }
-    // const _end = end == null ? strInc(_start) : this._keyEncoding.pack(end)
-    this._tn.clearRange(start, end)
+  clearRange(start?: KeyIn, end?: KeyIn) {
+    const range = this.subspace.packRange(start, end)
+
+    this._tn.clearRange(range.begin, range.end)
   }
 
-  /** An alias for unary clearRange */
+  /**
+   * This method is similar to *clearRange*, but performs the operation
+   * on a key range specified by `prefix` instead of start and end.
+   *
+   * @see Transaction.clearRange
+   */
   clearRangeStartsWith(prefix: KeyIn) {
-    this.clearRange(prefix)
+    const range = this.subspace.packRangeStartsWith(prefix)
+
+    this._tn.clearRange(range.begin, range.end)
   }
 
   watch(key: KeyIn, opts?: WatchOptions): Watch {
     const throwAll = opts && opts.throwAllErrors
-    const watch = this._tn.watch(this._keyEncoding.pack(key), !throwAll)
+    const watch = this._tn.watch(this.subspace.packKey(key), !throwAll)
     // Suppress the global unhandledRejection handler when a watch errors
     watch.promise.catch(doNothing)
     return watch
   }
 
-  addReadConflictRange(start: KeyIn, end: KeyIn) {
-    this._tn.addReadConflictRange(this._keyEncoding.pack(start), this._keyEncoding.pack(end))
+  addReadConflictRange(start?: KeyIn, end?: KeyIn) {
+    const range = this.subspace.packRange(start, end, true)
+    this._tn.addReadConflictRange(range.begin, range.end)
+  }
+  addReadConflictRangeStartsWith(prefix: KeyIn) {
+    const range = this.subspace.packRangeStartsWith(prefix)
+    this._tn.addReadConflictRange(range.begin, range.end)
   }
   addReadConflictKey(key: KeyIn) {
-    const keyBuf = this._keyEncoding.pack(key)
+    const keyBuf = this.subspace.packKey(key)
     this._tn.addReadConflictRange(keyBuf, strNext(keyBuf))
   }
 
-  addWriteConflictRange(start: KeyIn, end: KeyIn) {
-    this._tn.addWriteConflictRange(this._keyEncoding.pack(start), this._keyEncoding.pack(end))
+  addWriteConflictRange(start?: KeyIn, end?: KeyIn) {
+    const range = this.subspace.packRange(start, end, true)
+    this._tn.addWriteConflictRange(range.begin, range.end)
+  }
+  addWriteConflictRangeStartsWith(prefix: KeyIn) {
+    const range = this.subspace.packRangeStartsWith(prefix)
+    this._tn.addWriteConflictRange(range.begin, range.end)
   }
   addWriteConflictKey(key: KeyIn) {
-    const keyBuf = this._keyEncoding.pack(key)
+    const keyBuf = this.subspace.packKey(key)
     this._tn.addWriteConflictRange(keyBuf, strNext(keyBuf))
   }
 
@@ -608,7 +657,7 @@ export default class Transaction<KeyIn = NativeValue, KeyOut = Buffer, ValIn = N
   }
 
   getAddressesForKey(key: KeyIn): string[] {
-    return this._tn.getAddressesForKey(this._keyEncoding.pack(key))
+    return this._tn.getAddressesForKey(this.subspace.packKey(key))
   }
 
   // **** Atomic operations
@@ -617,10 +666,10 @@ export default class Transaction<KeyIn = NativeValue, KeyOut = Buffer, ValIn = N
     this._tn.atomicOp(opType, key, oper)
   }
   atomicOpKB(opType: MutationType, key: KeyIn, oper: Buffer) {
-    this._tn.atomicOp(opType, this._keyEncoding.pack(key), oper)
+    this._tn.atomicOp(opType, this.subspace.packKey(key), oper)
   }
   atomicOp(opType: MutationType, key: KeyIn, oper: ValIn) {
-    this._tn.atomicOp(opType, this._keyEncoding.pack(key), this._valueEncoding.pack(oper))
+    this._tn.atomicOp(opType, this.subspace.packKey(key), this.subspace.packValue(oper))
   }
 
   /**
@@ -673,14 +722,14 @@ export default class Transaction<KeyIn = NativeValue, KeyOut = Buffer, ValIn = N
   }
 
   setVersionstampedKeyRaw(keyBytes: Buffer, value: ValIn) {
-    this.atomicOpNative(MutationType.SetVersionstampedKey, keyBytes, this._valueEncoding.pack(value))
+    this.atomicOpNative(MutationType.SetVersionstampedKey, keyBytes, this.subspace.packValue(value))
   }
 
   // This sets the key [prefix, 10 bytes versionstamp, suffix] to value.
   setVersionstampedKeyBuf(prefix: Buffer | undefined, suffix: Buffer | undefined, value: ValIn) {
     const key = packVersionstampPrefixSuffix(prefix, suffix, true)
     // console.log('key', key)
-    this.atomicOpNative(MutationType.SetVersionstampedKey, key, this._valueEncoding.pack(value))
+    this.atomicOpNative(MutationType.SetVersionstampedKey, key, this.subspace.packValue(value))
   }
 
   private _addBakeItem<T>(item: T, transformer: Transformer<T, any>, code: Buffer | null) {
@@ -698,19 +747,15 @@ export default class Transaction<KeyIn = NativeValue, KeyOut = Buffer, ValIn = N
   // key to be baked out with a versionstamp after it, use
   // setVersionstampSuffixedKey.
   setVersionstampedKey(key: KeyIn, value: ValIn, bakeAfterCommit: boolean = true) {
-    if (!this._keyEncoding.packUnboundVersionstamp) {
-      throw TypeError('Key encoding does not support unbound versionstamps. Use setVersionstampPrefixedValue instead')
-    }
-
-    const pack = this._keyEncoding.packUnboundVersionstamp(key)
+    const pack = this.subspace.packKeyUnboundVersionstamp(key)
     const code = this._bakeCode(pack)
     this.setVersionstampedKeyRaw(packVersionstamp(pack, true), value)
 
-    if (bakeAfterCommit) this._addBakeItem(key, this._keyEncoding, code)
+    if (bakeAfterCommit) this._addBakeItem(key, this.subspace._bakedKeyXf, code)
   }
 
   setVersionstampSuffixedKey(key: KeyIn, value: ValIn, suffix?: Buffer) {
-    const prefix = asBuf(this._keyEncoding.pack(key))
+    const prefix = asBuf(this.subspace.packKey(key))
     this.setVersionstampedKeyBuf(prefix, suffix, value)
   }
 
@@ -721,16 +766,11 @@ export default class Transaction<KeyIn = NativeValue, KeyOut = Buffer, ValIn = N
   }
 
   setVersionstampedValue(key: KeyIn, value: ValIn, bakeAfterCommit: boolean = true) {
-    // This is super similar to setVersionstampedKey. I wish I could reuse the code.
-    if (!this._valueEncoding.packUnboundVersionstamp) {
-      throw TypeError('Value encoding does not support unbound versionstamps. Use setVersionstampPrefixedValue instead')
-    }
-
-    const pack = this._valueEncoding.packUnboundVersionstamp(value)
+    const pack = this.subspace.packValueUnboundVersionstamp(value)
     const code = this._bakeCode(pack)
     this.setVersionstampedValueRaw(key, packVersionstamp(pack, false))
 
-    if (bakeAfterCommit) this._addBakeItem(value, this._valueEncoding, code)
+    if (bakeAfterCommit) this._addBakeItem(value, this.subspace.valueXf, code)
   }
 
   /**
@@ -739,7 +779,7 @@ export default class Transaction<KeyIn = NativeValue, KeyOut = Buffer, ValIn = N
    * prefix is only supported on API version 520+.
    */
   setVersionstampPrefixedValue(key: KeyIn, value?: ValIn, prefix?: Buffer) {
-    const valBuf = value !== undefined ? asBuf(this._valueEncoding.pack(value)) : undefined
+    const valBuf = value !== undefined ? asBuf(this.subspace.packValue(value)) : undefined
     const val = packVersionstampPrefixSuffix(prefix, valBuf, false)
     this.atomicOpKB(MutationType.SetVersionstampedValue, key, val)
   }
@@ -751,10 +791,10 @@ export default class Transaction<KeyIn = NativeValue, KeyOut = Buffer, ValIn = N
    * using setVersionstampedValue with tuples, just call get().
    */
   async getVersionstampPrefixedValue(key: KeyIn): Promise<{stamp: Buffer, value?: ValOut} | null> {
-    const val = await this._tn.get(this._keyEncoding.pack(key), this.isSnapshot)
+    const val = await this._tn.get(this.subspace.packKey(key), this.isSnapshot)
 
     if (val == null) {
-      return null;
+      return null
     }
 
     return val.length <= 10
@@ -770,7 +810,7 @@ export default class Transaction<KeyIn = NativeValue, KeyOut = Buffer, ValIn = N
         // for the decoder and that can cause issues. We'll just return null
         // in that case - but, yeah, controversial. You might want some other
         // encoding or something. File an issue if this causes you grief.
-        value: this._valueEncoding.unpack(val.slice(10))
+        value: this.subspace.unpackValue(val.slice(10))
       }
   }
 
diff --git a/scripts/bindingtester.ts b/scripts/bindingtester.ts
index 3f23db5..a0c468e 100755
--- a/scripts/bindingtester.ts
+++ b/scripts/bindingtester.ts
@@ -666,7 +666,7 @@ const makeMachine = (db: Database, initialName: Buffer) => {
     },
     async DIRECTORY_RANGE() {
       const keyTuple = await popNValues()
-      const {begin, end} = getCurrentSubspace().withKeyEncoding(tupleStrict).packRange(keyTuple)
+      const {begin, end} = getCurrentSubspace().withKeyEncoding(tupleStrict).packRangeStartsWith(keyTuple)
       pushValue(begin); pushValue(end)
     },
     async DIRECTORY_CONTAINS() {