moves to a simpler and faster serialization technique that uses keys alone and does not require values; eliminates repeated term serialization

Author: jacoscaz

package.json

@@ -1,6 +1,6 @@
 {
   "name": "quadstore",
-  "version": "11.0.8",
+  "version": "12.0.0-alpha.2",
   "description": "A LevelDB-backed graph database for Node.js and the browser. Supports quads, RDF/JS interfaces and SPARQL queries.",
   "keywords": [
     "node",

src/get/index.ts

@@ -17,10 +17,9 @@ import { ResultType, LevelQuery } from '../types';
 import { arrStartsWith } from '../utils/stuff';
 import { emptyObject, separator } from '../utils/constants';
 import { LevelIterator } from './leveliterator';
-import { quadReader, quadWriter, writePattern } from '../serialization';
+import {quadReader, twoStepsQuadWriter, writePattern} from '../serialization';
 import { SortingIterator } from './sortingiterator';
 import { AbstractLevel } from 'abstract-level';
-import { viewUint8ArrayAsUint16Array } from '../serialization/utils';
 
 const SORTING_KEY = Symbol();
 
@@ -47,9 +46,8 @@ const getLevelQueryForIndex = (pattern: Pattern, index: InternalIndex, prefixes:
     [indexQuery.gte ? 'gte' : 'gt']: indexQuery.gt,
     [indexQuery.lte ? 'lte' : 'lt']: indexQuery.lt,
     keys: true,
-    values: true,
+    values: false,
     keyEncoding: 'utf8',
-    valueEncoding: 'view',
   };
   if (typeof opts.limit === 'number') {
     levelOpts.limit = opts.limit;
@@ -78,8 +76,8 @@ export const getStream = async (store: Quadstore, pattern: Pattern, opts: GetOpt
 
   if (levelQueryFull !== null) {
     const { index, level, order } = levelQueryFull;
-    let iterator: AsyncIterator<Quad> = new LevelIterator(store.db.iterator(level), (key: string, value: Uint8Array) => {
-      return quadReader.read(key, index.prefix.length, viewUint8ArrayAsUint16Array(value), 0, index.terms, dataFactory, prefixes);
+    let iterator: AsyncIterator<Quad> = new LevelIterator(store.db.iterator(level), (key: string) => {
+      return quadReader.read(key, index.prefix.length, index.terms, dataFactory, prefixes);
     });
     return { type: ResultType.QUADS, order, iterator, index: index.terms, resorted: false };
   }
@@ -88,12 +86,12 @@ export const getStream = async (store: Quadstore, pattern: Pattern, opts: GetOpt
 
   if (levelQueryNoOpts !== null) {
     const { index, level, order } = levelQueryNoOpts;
-    let iterator: AsyncIterator<Quad> = new LevelIterator(store.db.iterator(level), (key: string, value: Uint8Array) => {
-      return quadReader.read(key, index.prefix.length, viewUint8ArrayAsUint16Array(value), 0, index.terms, dataFactory, prefixes);
+    let iterator: AsyncIterator<Quad> = new LevelIterator(store.db.iterator(level), (key: string) => {
+      return quadReader.read(key, index.prefix.length, index.terms, dataFactory, prefixes);
     });
     if (typeof opts.order !== 'undefined' && !arrStartsWith(opts.order, order)) {
       const digest = (item: Quad): SortableQuad => {
-        (item as SortableQuad)[SORTING_KEY] = quadWriter.write('', undefined, 0, item, <TermName[]>opts.order, prefixes) + separator;
+        (item as SortableQuad)[SORTING_KEY] = twoStepsQuadWriter.ingest(item, prefixes).write('', <TermName[]>opts.order) + separator;
         return (item as SortableQuad);
       };
       const compare = opts.reverse === true ? compareSortableQuadsReverse : compareSortableQuads;

src/quadstore.ts

@@ -48,15 +48,16 @@ import {
   defaultIndexes,
   separator,
   levelPutOpts,
-  levelDelOpts,
+  levelDelOpts, emptyValue,
 } from './utils/constants';
 import { consumeOneByOne } from './utils/consumeonebyone';
 import { consumeInBatches } from './utils/consumeinbatches';
 import { uid } from './utils/uid';
 import { getApproximateSize, getStream } from './get';
 import { Scope } from './scope';
-import { quadWriter } from './serialization/quads';
-import { viewUint16ArrayAsUint8Array } from './serialization/utils';
+import {twoStepsQuadWriter} from './serialization/quads';
+import {Util} from 'n3';
+import prefixes = Util.prefixes;
 
 export class Quadstore implements Store {
 
@@ -183,13 +184,13 @@ export class Quadstore implements Store {
     return await getApproximateSize(this, pattern, opts);
   }
 
-  private _batchPut(quad: Quad, value: Uint16Array, baseValueOffset: number, batch: AbstractChainedBatch<any, any, any>): AbstractChainedBatch<any, any, any> {
-    const { indexes } = this;
-    for (let i = 0, il = indexes.length, index, valueOffset; i < il; i += 1) {
-      valueOffset = baseValueOffset + i * 16;
+  private _batchPut(quad: Quad, batch: AbstractChainedBatch<any, any, any>): AbstractChainedBatch<any, any, any> {
+    const { indexes, prefixes } = this;
+    twoStepsQuadWriter.ingest(quad, prefixes);
+    for (let i = 0, il = indexes.length, index; i < il; i += 1) {
       index = indexes[i];
-      const key = quadWriter.write(index.prefix, value, valueOffset, quad, index.terms, this.prefixes);
-      batch = batch.put(key, viewUint16ArrayAsUint8Array(value, valueOffset, 16), levelPutOpts);
+      const key = twoStepsQuadWriter.write(index.prefix, index.terms);
+      batch = batch.put(key, emptyValue, levelPutOpts);
     }
     return batch;
   }
@@ -201,35 +202,32 @@ export class Quadstore implements Store {
     if (opts.scope) {
       quad = opts.scope.parseQuad(quad, batch);
     }
-    const value = new Uint16Array(16 * indexes.length);
-    this._batchPut(quad, value, 0, batch);
+    this._batchPut(quad, batch);
     await this.writeBatch(batch, opts);
     return { type: ResultType.VOID };
   }
 
   async multiPut(quads: Quad[], opts: PutOpts = emptyObject): Promise<VoidResult> {
     this.ensureReady();
     const { indexes, db } = this;
-    const value = new Uint16Array(16 * indexes.length * quads.length);
-    let valueOffset = 0;
     let batch = db.batch();
     for (let q = 0, ql = quads.length, quad; q < ql; q += 1) {
       quad = quads[q];
-      valueOffset = q * indexes.length * 16;
       if (opts.scope) {
         quad = opts.scope.parseQuad(quad, batch);
       }
-      this._batchPut(quad, value, valueOffset, batch);
+      this._batchPut(quad, batch);
     }
     await this.writeBatch(batch, opts);
     return { type: ResultType.VOID };
   }
 
   private _batchDel(quad: Quad, batch: AbstractChainedBatch<any, any, any>): AbstractChainedBatch<any, any, any> {
-    const { indexes } = this;
+    const { indexes, prefixes } = this;
+    twoStepsQuadWriter.ingest(quad, prefixes);
     for (let i = 0, il = indexes.length, index; i < il; i += 1) {
       index = indexes[i];
-      const key = quadWriter.write(index.prefix, undefined, 0, quad, index.terms, this.prefixes);
+      const key = twoStepsQuadWriter.write(index.prefix, index.terms);
       batch = batch.del(key, levelDelOpts);
     }
     return batch;
@@ -259,8 +257,7 @@ export class Quadstore implements Store {
     const { indexes, db } = this;
     const batch = db.batch();
     this._batchDel(oldQuad, batch);
-    const value = new Uint16Array(16 * indexes.length);
-    this._batchPut(newQuad, value, 0, batch);
+    this._batchPut(newQuad, batch);
     await this.writeBatch(batch, opts);
     return { type: ResultType.VOID };
   }
@@ -273,12 +270,9 @@ export class Quadstore implements Store {
       oldQuad = oldQuads[oq];
       this._batchDel(oldQuad, batch);
     }
-    const value = new Uint16Array(16 * indexes.length * newQuads.length);
-    let valueOffset = 0;
     for (let nq = 0, nql = newQuads.length, newQuad; nq < nql; nq += 1) {
-      valueOffset = nq * indexes.length * 16;
       newQuad = newQuads[nq];
-      this._batchPut(newQuad, value, valueOffset, batch);
+      this._batchPut(newQuad, batch);
     }
     await this.writeBatch(batch, opts);
     return { type: ResultType.VOID };

src/serialization/index.ts

@@ -1,3 +1,3 @@
 
-export { quadWriter, quadReader } from './quads';
+export { twoStepsQuadWriter, quadReader } from './quads';
 export { writePattern } from './patterns';

src/serialization/patterns.ts

@@ -1,23 +1,30 @@
 
 import type { Literal } from 'rdf-js';
-import type { InternalIndex, Pattern, Prefixes, IndexQuery } from '../types';
+import type {InternalIndex, Pattern, Prefixes, IndexQuery, SerializedTerm} from '../types';
 
 import * as xsd from './xsd';
 import { encode } from './fpstring';
 import { separator, boundary } from '../utils/constants';
 import { blankNodeWriter, defaultGraphWriter, genericLiteralWriter, langStringLiteralWriter, namedNodeWriter,
          numericLiteralWriter, stringLiteralWriter } from './terms';
 
+const serialized: SerializedTerm = {
+  type: '',
+  value: '',
+  lengths: '',
+};
 
 const patternLiteralWriter = {
-  write(term: Literal) {
+  write(term: Literal, prefixes: Prefixes) {
     if (term.language) {
-      return langStringLiteralWriter.write(undefined, 0, term, separator);
+      langStringLiteralWriter.write(term, serialized, prefixes);
+      return;
     }
     if (term.datatype) {
       switch (term.datatype.value) {
         case xsd.string:
-          return stringLiteralWriter.write(undefined, 0, term);
+          stringLiteralWriter.write(term, serialized, prefixes);
+          return;
         case xsd.integer:
         case xsd.double:
         case xsd.decimal:
@@ -33,14 +40,18 @@ const patternLiteralWriter = {
         case xsd.unsignedShort:
         case xsd.unsignedByte:
         case xsd.positiveInteger:
-          return numericLiteralWriter.write(undefined, 0, term, separator, encode(term.value), true);
+          numericLiteralWriter.write(term, serialized, prefixes, true, encode(term.value));
+          return;
         case xsd.dateTime:
-          return numericLiteralWriter.write(undefined, 0, term, separator, encode(new Date(term.value).valueOf()), true);
+          numericLiteralWriter.write(term, serialized, prefixes, true, encode(new Date(term.value).valueOf()));
+          return;
         default:
-          return genericLiteralWriter.write(undefined, 0, term, separator);
+          genericLiteralWriter.write(term, serialized, prefixes);
+          return;
       }
     }
-    return stringLiteralWriter.write(undefined, 0, term);
+    stringLiteralWriter.write(term, serialized, prefixes);
+    return;
   }
 };
 
@@ -69,43 +80,55 @@ export const writePattern = (pattern: Pattern, index: InternalIndex, prefixes: P
       case 'Range':
         didRange = true;
         if (term.gt) {
-          gt += patternLiteralWriter.write(term.gt);
+          patternLiteralWriter.write(term.gt, prefixes);
+          gt += serialized.value;
           gte = false;
         } else if (term.gte) {
-          gt += patternLiteralWriter.write(term.gte);
+          patternLiteralWriter.write(term.gte, prefixes);
+          gt += serialized.value;
           gte = true;
         }
         if (term.lt) {
-          lt += patternLiteralWriter.write(term.lt);
+          patternLiteralWriter.write(term.lt, prefixes);
+          lt += serialized.value;
           lte = false;
         } else if (term.lte) {
-          lt += patternLiteralWriter.write(term.lte);
+          patternLiteralWriter.write(term.lte, prefixes);
+          lt += serialized.value;
           lte = true;
         }
         break;
       case 'Literal':
         didLiteral = true;
-        gt += patternLiteralWriter.write(term);
+        patternLiteralWriter.write(term, prefixes);
+        gt += serialized.value;
         gte = true;
-        lt += patternLiteralWriter.write(term);
+        patternLiteralWriter.write(term, prefixes);
+        lt += serialized.value;
         lte = true;
         break;
       case 'NamedNode':
-        gt += namedNodeWriter.write(undefined, 0, term, prefixes);
+        namedNodeWriter.write(term, serialized, prefixes);
+        gt += serialized.value;
         gte = true;
-        lt += namedNodeWriter.write(undefined, 0, term, prefixes);
+        namedNodeWriter.write(term, serialized, prefixes);
+        lt += serialized.value;
         lte = true;
         break;
       case 'BlankNode':
-        gt += blankNodeWriter.write(undefined, 0, term);
+        blankNodeWriter.write(term, serialized, prefixes);
+        gt += serialized.value;
         gte = true;
-        lt += blankNodeWriter.write(undefined, 0, term);
+        blankNodeWriter.write(term, serialized, prefixes);
+        lt += serialized.value;
         lte = true;
         break;
       case 'DefaultGraph':
-        gt += defaultGraphWriter.write(undefined, 0, term);
+        defaultGraphWriter.write(term, serialized, prefixes);
+        gt += serialized.value;
         gte = true;
-        lt += defaultGraphWriter.write(undefined, 0, term);
+        defaultGraphWriter.write(term, serialized, prefixes);
+        lt += serialized.value;
         lte = true;
         break;
     }

src/serialization/quads.ts

@@ -1,39 +1,65 @@
 
-import type { DataFactory, Term } from 'rdf-js';
-import type { Prefixes, Quad, TermName } from '../types';
+import type {DataFactory, Quad_Graph, Quad_Object, Quad_Predicate, Quad_Subject, Term} from 'rdf-js';
+import type {Prefixes, Quad, SerializedTerm, TermName} from '../types';
 
 import { separator } from '../utils/constants';
 import { termReader, termWriter } from './terms';
+import {padNumStart} from './utils';
 
-export const quadWriter = {
-  writtenValueLength: 0,
-  write(prefix: string, value: Uint16Array|undefined, baseValueOffset: number, quad: Quad, termNames: TermName[], prefixes: Prefixes) {
-    let ret = prefix;
-    let valueOffset = baseValueOffset;
+type TwoStepsQuadWriter = Record<TermName, SerializedTerm> & {
+  ingest(quad: Quad, prefixes: Prefixes): TwoStepsQuadWriter;
+  write(prefix: string, termNames: TermName[]): string;
+};
+
+export const twoStepsQuadWriter: TwoStepsQuadWriter = {
+  subject: { type: '', value: '', lengths: '' },
+  predicate: { type: '', value: '', lengths: '' },
+  object: { type: '', value: '', lengths: '' },
+  graph: { type: '', value: '', lengths: '' },
+  ingest(quad: Quad, prefixes: Prefixes) {
+    termWriter.write(quad.subject, this.subject, prefixes);
+    termWriter.write(quad.predicate, this.predicate, prefixes);
+    termWriter.write(quad.object, this.object, prefixes);
+    termWriter.write(quad.graph, this.graph, prefixes);
+    return this;
+  },
+  write(prefix: string, termNames: TermName[]) {
+    let key = prefix;
+    let lengths = '';
     for (let t = 0, term; t < termNames.length; t += 1) {
-      term = quad[termNames[t]];
-      ret += termWriter.write(value, valueOffset, term, prefixes) + separator;
-      valueOffset += termWriter.writtenValueLength;
+      term = this[termNames[t]];
+      key += term.value + separator;
+      lengths += term.type + term.lengths;
     }
-    this.writtenValueLength = valueOffset - baseValueOffset;
-    return ret;
+    return key + lengths + padNumStart(lengths.length);
   },
 };
 
-export const quadReader = {
+type QuadReader = Record<TermName, Term | null>
+  & { keyOffset: number; lengthsOffset: number; }
+  & { read(key: string, keyOffset: number, termNames: TermName[], factory: DataFactory, prefixes: Prefixes): Quad; }
+  ;
+
+export const quadReader: QuadReader = {
   subject: null,
   predicate: null,
   object: null,
   graph: null,
-  read(key: string, keyOffset: number, value: Uint16Array, valueOffset: number, termNames: TermName[], factory: DataFactory, prefixes: Prefixes): Quad {
+  keyOffset: 0,
+  lengthsOffset: 0,
+  read(key: string, keyOffset: number, termNames: TermName[], factory: DataFactory, prefixes: Prefixes): Quad {
+    this.lengthsOffset = key.length - parseInt(key.slice(-4)) - 4;
+    this.keyOffset = keyOffset;
     for (let t = 0, termName; t < termNames.length; t += 1) {
       termName = termNames[t];
-      // @ts-ignore
-      this[termName] = termReader.read(key, keyOffset, value, valueOffset, factory, prefixes);
-      keyOffset += termReader.readKeyChars + separator.length;
-      valueOffset += termReader.readValueLength;
+      this[termName] = termReader.read(key, this, factory, prefixes);
+      this.keyOffset += separator.length;
     }
-    // @ts-ignore
-    return factory.quad(this.subject, this.predicate, this.object, this.graph);
+    return factory.quad(
+      this.subject! as Quad_Subject,
+      this.predicate! as Quad_Predicate,
+      this.object! as Quad_Object,
+      this.graph! as Quad_Graph,
+    );
   },
 };

src/serialization/terms.ts

@@ -3,10 +3,10 @@ export const sliceString = (source: string, offset: number, length: number): str
   return source.slice(offset, offset + length);
 };
 
-export const viewUint8ArrayAsUint16Array = (source: Uint8Array): Uint16Array => {
-  return new Uint16Array(source.buffer, source.byteOffset, source.byteLength / 2);
-};
-
-export const viewUint16ArrayAsUint8Array = (source: Uint16Array, offset: number, length: number): Uint8Array => {
-  return new Uint8Array(source.buffer, source.byteOffset + offset * 2, length * 2);
+export const padNumStart = (val: number) => {
+  if (val < 10) return '000' + val;
+  if (val < 100) return '00' + val;
+  if (val < 1000) return '0' + val;
+  if (val < 10000) return '' + val;
+  throw new Error('too long: ' + val);
 };

src/serialization/utils.ts

@@ -2,7 +2,7 @@
 import type { Readable } from 'stream';
 import type { AbstractChainedBatch, AbstractLevel } from 'abstract-level'
 import type { AsyncIterator } from 'asynciterator';
-import type { Literal, DataFactory, Quad_Subject, Quad_Predicate, Quad_Object, Quad_Graph, Quad } from 'rdf-js';
+import type { Literal, DataFactory, Quad_Subject, Quad_Predicate, Quad_Object, Quad_Graph, Quad, Term } from 'rdf-js';
 import type { Scope } from '../scope';
 import type { AbstractIteratorOptions } from 'abstract-level';
 
@@ -15,6 +15,7 @@ export interface BatchOpts {
 }
 
 export interface DelOpts extends BatchOpts {
+  scope?: Scope,
 }
 
 export interface PutOpts extends BatchOpts {
@@ -129,3 +130,23 @@ export interface LevelQuery<LK, LV> {
   order: TermName[];
   index: InternalIndex;
 }
+
+export interface SerializedTerm {
+  value: string;
+  type: string;
+  lengths: string;
+}
+
+export interface ReadingState {
+  keyOffset: number;
+  lengthsOffset: number;
+}
+
+export interface TermReader<T extends Term> {
+  read(key: string, state: ReadingState, factory: DataFactory, prefixes: Prefixes): T;
+}
+
+export type TermWriter<T extends Term, E extends 'T' | 'F'> = E extends 'T'
+  ? { write(node: T, serialized: SerializedTerm, prefixes: Prefixes, rangeMode: boolean, encodedValue: string): void }
+  : { write(node: T, serialized: SerializedTerm, prefixes: Prefixes): void }
+  ;

src/types/index.ts

@@ -31,3 +31,5 @@ export const levelPutOpts: AbstractChainedBatchPutOptions<any, any, any> = {
 export const levelDelOpts: AbstractChainedBatchDelOptions<any, any> = {
   keyEncoding: 'utf8',
 };
+
+export const emptyValue = new Uint8Array(0);

src/utils/constants.ts

@@ -28,7 +28,7 @@ export const runPutTests = () => {
       const newQuad = dataFactory.quad(
         dataFactory.namedNode('ex://s'),
         dataFactory.namedNode('ex://p'),
-        dataFactory.literal(''.padStart(2000, 'aaabbb')),
+        dataFactory.literal(''.padStart(129, 'aaabbb')),
         dataFactory.namedNode('ex://g'),
       );
       await store.put(newQuad);

test/quadstore/put.ts

@@ -2,15 +2,13 @@
 import type {InternalIndex} from '../../dist/esm/types';
 
 import * as xsd from '../../dist/esm/serialization/xsd';
-import { quadWriter, quadReader } from '../../dist/esm/serialization';
+import {quadReader, twoStepsQuadWriter} from '../../dist/esm/serialization';
 import { toEqualQuad } from '../utils/expect';
 
 export const runSerializationTests = () => {
 
   describe('Quadstore serialization', function () {
 
-    const value = new Uint16Array(32);
-
     it('Should serialize and deserialize quads with named nodes', function () {
       const { store } = this;
       const { indexes, prefixes, dataFactory: factory } = store;
@@ -21,8 +19,8 @@ export const runSerializationTests = () => {
         factory.namedNode('http://ex.com/g'),
       );
       indexes.forEach((index: InternalIndex) => {
-        const key = quadWriter.write(index.prefix, value, 0, quad, index.terms, prefixes);
-        const read = quadReader.read(key, index.prefix.length, value, 0, index.terms, factory, prefixes);
+        const key = twoStepsQuadWriter.ingest(quad, prefixes).write(index.prefix, index.terms);
+        const read = quadReader.read(key, index.prefix.length, index.terms, factory, prefixes);
         toEqualQuad(read, quad);
       });
     });
@@ -37,8 +35,8 @@ export const runSerializationTests = () => {
         factory.defaultGraph(),
       );
       indexes.forEach((index: InternalIndex) => {
-        const key = quadWriter.write(index.prefix, value, 0, quad, index.terms, prefixes);
-        const read = quadReader.read(key, index.prefix.length, value, 0, index.terms, factory, prefixes);
+        const key = twoStepsQuadWriter.ingest(quad, prefixes).write(index.prefix, index.terms);
+        const read = quadReader.read(key, index.prefix.length, index.terms, factory, prefixes);
         toEqualQuad(read, quad);
       });
     });
@@ -53,8 +51,8 @@ export const runSerializationTests = () => {
         factory.namedNode('http://ex.com/g'),
       );
       indexes.forEach((index: InternalIndex) => {
-        const key = quadWriter.write(index.prefix, value, 0, quad, index.terms, prefixes);
-        const read = quadReader.read(key, index.prefix.length, value, 0, index.terms, factory, prefixes);
+        const key = twoStepsQuadWriter.ingest(quad, prefixes).write(index.prefix, index.terms);
+        const read = quadReader.read(key, index.prefix.length, index.terms, factory, prefixes);
         toEqualQuad(read, quad);
       });
     });
@@ -69,8 +67,8 @@ export const runSerializationTests = () => {
         factory.namedNode('http://ex.com/g'),
       );
       indexes.forEach((index: InternalIndex) => {
-        const key = quadWriter.write(index.prefix, value, 0, quad, index.terms, prefixes);
-        const read = quadReader.read(key, index.prefix.length, value, 0, index.terms, factory, prefixes);
+        const key = twoStepsQuadWriter.ingest(quad, prefixes).write(index.prefix, index.terms);
+        const read = quadReader.read(key, index.prefix.length, index.terms, factory, prefixes);
         toEqualQuad(read, quad);
       });
     });
@@ -85,8 +83,8 @@ export const runSerializationTests = () => {
         factory.namedNode('http://ex.com/g'),
       );
       indexes.forEach((index: InternalIndex) => {
-        const key = quadWriter.write(index.prefix, value, 0, quad, index.terms, prefixes);
-        const read = quadReader.read(key, index.prefix.length, value, 0, index.terms, factory, prefixes);
+        const key = twoStepsQuadWriter.ingest(quad, prefixes).write(index.prefix, index.terms);
+        const read = quadReader.read(key, index.prefix.length, index.terms, factory, prefixes);
         toEqualQuad(read, quad);
       });
     });
@@ -96,12 +94,12 @@ export const runSerializationTests = () => {
       const quad = factory.quad(
         factory.namedNode('http://ex.com/s'),
         factory.namedNode('http://ex.com/p'),
-        factory.literal(''.padStart(2000, 'abab')),
+        factory.literal(''.padStart(129, 'abab')),
         factory.namedNode('http://ex.com/g'),
       );
       indexes.forEach((index: InternalIndex) => {
-        const key = quadWriter.write(index.prefix, value, 0, quad, index.terms, prefixes);
-        const read = quadReader.read(key, index.prefix.length, value, 0, index.terms, factory, prefixes);
+        const key = twoStepsQuadWriter.ingest(quad, prefixes).write(index.prefix, index.terms);
+        const read = quadReader.read(key, index.prefix.length, index.terms, factory, prefixes);
         toEqualQuad(read, quad);
       });
     });