@thi.ng/column-store 0.4.0 → 0.5.1

package/README.md

@@ -34,6 +34,8 @@
     - [AND](#and)
     - [Negation](#negation)
     - [Predicate-based matchers](#predicate-based-matchers)
+    - [Row ranges](#row-ranges)
+    - [Value ranges](#value-ranges)
   - [Custom operators](#custom-operators)
   - [Result aggregation](#result-aggregation)
   - [Query ranges](#query-ranges)
@@ -55,10 +57,11 @@ As the name indicates, data is stored in different columns, where each column
 manages its own schema, value validation, backing storage, indexing,
 serialization etc.
 
-From a user's POV, columns are not (usually) used directly, but via table, which
-acts as facade to the various configured columns. Data items are added as JS
-objects to a table, which then pulls out related values, validates them and the
-delegates them to the columns.
+From a user's POV, columns are not (usually) used directly, but accessed via a
+table, which provides row-based access to compound data records and acts as
+facade to the various configured columns. Data records are added as JS objects
+to a table, which then pulls out related values, validates them and the
+delegates them to the individual columns for encoding & storage.
 
 An example table definition looks like this (explanation of column types in next
 section below):
@@ -66,8 +69,17 @@ section below):
 ```ts tangle:export/readme-types.ts
 import { Table, FLAG_DICT, FLAG_UNIQUE } from "@thi.ng/column-store";
 
+// schema for a single row item
+interface Item {
+    id: number;
+    name: string;
+    aliases?: string[];
+    latlon: number[] | Float32Array;
+    tags: string[];
+}
+
 // define a table with the given columns
-const table = new Table({
+const table = new Table<Item>({
 
     // column of single numeric values
     // (default cardinality makes values required)
@@ -367,6 +379,30 @@ can be used, otherwise the behavior is:
 - [`matchPartialRow`](https://docs.thi.ng/umbrella/column-store/classes/Query.html#matchpartialrow):
   apply predicate to partial row (only selected columns)
 
+#### Row ranges
+
+The
+[`rowRange`](https://docs.thi.ng/umbrella/column-store/classes/Query.html#rowrange)
+operator selects the given `start` (inclusive) .. `end` (exclusive) range of row
+indices.
+
+```ts
+// select first ten rows
+query.rowRange(0, 10);
+```
+
+#### Value ranges
+
+The
+[`valueRange`](https://docs.thi.ng/umbrella/column-store/classes/Query.html#valuerange)
+operator selects rows based on a given column's `start` .. `end` vaulue range
+(both inclusive) of row indices.
+
+```ts
+// select rows where ID is in closed [100,109] interval
+query.valueRange("id", 100, 109);
+```
+
 ### Custom operators
 
 Custom query operators can be registered via
@@ -412,7 +448,7 @@ For Node.js REPL:
 const cs = await import("@thi.ng/column-store");
 ```
 
-Package sizes (brotli'd, pre-treeshake): ESM: 4.67 KB
+Package sizes (brotli'd, pre-treeshake): ESM: 5.37 KB
 
 ## Dependencies
 
@@ -438,7 +474,13 @@ import {
     FLAG_UNIQUE,
 } from "@thi.ng/column-store";
 
-const table = new Table({
+interface Item {
+    id: number;
+    type: string;
+    tags: string[];
+}
+
+const table = new Table<Item>({
     // ID column stores 8bit ints (typed array)
     id: { type: "u8" },
     // Type column stores indexed strings

package/api.d.ts

@@ -1,8 +1,9 @@
-import type { FloatType, Fn3, IntType, Maybe, UintType } from "@thi.ng/api";
+import type { FloatType, Fn3, IntType, Maybe, Predicate, UintType } from "@thi.ng/api";
 import type { BitmapIndex } from "./bitmap.js";
 import type { QueryCtx } from "./query.js";
 import type { Table } from "./table.js";
-export type ColumnSchema = Record<string, ColumnSpec>;
+export type ColumnID<T extends Row> = Exclude<keyof T, number | symbol>;
+export type ColumnSchema<T extends Row> = Record<ColumnID<T>, ColumnSpec>;
 export type NumericType = IntType | UintType | FloatType;
 export type VectorType = `${NumericType}vec`;
 export type Cardinality = [number, number];
@@ -55,7 +56,7 @@ export interface ColumnTypeSpec {
      * Factory function to instantiate a colum type for given table, column name
      * & spec.
      */
-    impl: Fn3<Table, string, ColumnSpec, IColumn>;
+    impl: Fn3<Table<any>, string, ColumnSpec, IColumn>;
     /**
      * Bit mask of supported flags (default: 0, i.e. none allowed). During
      * column validation, the (inverted) mask will be applied to the user
@@ -99,6 +100,8 @@ export interface IColumn {
      * @param end
      */
     indexOf(value: any, start?: number, end?: number): number;
+    findIndex(pred: Predicate<any>, start?: number, end?: number): number;
+    findLastIndex(pred: Predicate<any>, start?: number, end?: number): number;
     /**
      * Returns value at given row.
      *
@@ -123,9 +126,9 @@ export interface IColumn {
     getRowKey(i: number): any;
     valueKey(value: any): any;
 }
-export interface SerializedTable {
-    schema: ColumnSchema;
-    columns: Record<string, SerializedColumn>;
+export interface SerializedTable<T extends Row> {
+    schema: ColumnSchema<T>;
+    columns: Record<ColumnID<T>, SerializedColumn>;
     length: number;
 }
 export interface SerializedColumn {
@@ -137,13 +140,16 @@ export interface SerializedIndex {
     next: number;
 }
 export type Row = Record<string, any>;
-export interface QueryTerm {
+export type RowWithMeta<T extends Row> = T & {
+    __row: number;
+};
+export interface QueryTerm<T extends Row> {
     type: string;
-    column?: string;
+    column?: ColumnID<T>;
     value: any;
     params?: any;
 }
-export type QueryTermOp = Fn3<QueryCtx, QueryTerm, Maybe<IColumn>, void>;
+export type QueryTermOp = Fn3<QueryCtx<any>, QueryTerm<any>, Maybe<IColumn>, void>;
 export interface QueryTermOpSpec {
     /**
      * Default mode is: "col";

package/bitmap.d.ts

@@ -30,6 +30,7 @@ export declare class Bitfield {
     first(start?: number, end?: number): number;
     setBit(id: number): void;
     clearBit(id: number): void;
+    fill(x: 0 | 1, start: number, end: number): this;
     ensure(size: number): Uint32Array<ArrayBufferLike>;
     removeBit(id: number): void;
 }

package/bitmap.js

@@ -1,3 +1,4 @@
+import { __clamp } from "./internal/indexof.js";
 class BitmapIndex {
   index = /* @__PURE__ */ new Map();
   /**
@@ -62,9 +63,13 @@ class Bitfield {
       }
     }
   }
-  first(start = 0, end = (this.buffer?.length ?? -1) * 32) {
+  first(start = 0, end) {
     const { buffer } = this;
-    if (!buffer || start >= end) return -1;
+    if (!buffer) return -1;
+    const max = buffer.length << 5;
+    start = __clamp(start, 0, max);
+    end = __clamp(end ?? max, 0, max);
+    if (start >= end) return -1;
     for (let i = start >>> 5, n = Math.min(Math.ceil(end / 32), buffer.length); i < n; i++) {
       let bits = buffer[i];
       while (bits) {
@@ -84,6 +89,22 @@ class Bitfield {
     const w = id >>> 5;
     this.ensure(w)[w] &= ~(1 << (id & 31));
   }
+  fill(x, start, end) {
+    const i = start >>> 5;
+    const j = end >>> 5;
+    let m = ~((1 << (start & 31)) - 1);
+    const buf = this.ensure(j);
+    if (i === j) {
+      m &= (1 << (end & 31)) - 1;
+      buf[i] = x ? buf[i] | m : buf[i] & ~m;
+    } else {
+      buf[i] = x ? buf[i] | m : buf[i] & ~m;
+      buf.fill(x ? -1 : 0, i + 1, j);
+      m = (1 << (end & 31)) - 1;
+      buf[j] = x ? buf[j] | m : buf[j] & ~m;
+    }
+    return this;
+  }
   ensure(size) {
     const b = this.buffer;
     if (!b || size >= b.length) {

package/columns/acolumn.d.ts

@@ -1,15 +1,16 @@
+import type { Predicate } from "@thi.ng/api";
 import type { BidirIndex } from "@thi.ng/bidir-index";
-import { type ColumnSpec, type IColumn, type SerializedColumn, type SerializedIndex } from "../api.js";
+import { type ColumnID, type ColumnSpec, type IColumn, type Row, type SerializedColumn, type SerializedIndex } from "../api.js";
 import { BitmapIndex } from "../bitmap.js";
 import type { Table } from "../table.js";
-export declare abstract class AColumn implements IColumn {
-    readonly id: string;
-    table: Table;
+export declare abstract class AColumn<T extends Row = Row> implements IColumn {
+    readonly id: ColumnID<T>;
+    table: Table<T>;
     spec: ColumnSpec;
     bitmap?: BitmapIndex;
     dict?: BidirIndex<any>;
     abstract isArray: boolean;
-    constructor(id: string, table: Table);
+    constructor(id: ColumnID<T>, table: Table<T>);
     abstract load(spec: SerializedColumn): void;
     reindex(): void;
     abstract validate(value: any): boolean;
@@ -20,6 +21,8 @@ export declare abstract class AColumn implements IColumn {
     abstract getRow(i: number): any;
     abstract getRowKey(i: number): any;
     abstract indexOf(value: any, start?: number, end?: number): number;
+    findIndex(pred: Predicate<any>, start?: number, end?: number): number;
+    findLastIndex(pred: Predicate<any>, start?: number, end?: number): number;
     encode(value: any): any;
     decode(value: any): any;
     protected loadDict(serialized: SerializedIndex): void;

package/columns/acolumn.js

@@ -1,8 +1,9 @@
-import { illegalArgs } from "@thi.ng/errors/illegal-arguments";
 import {
   FLAG_BITMAP
 } from "../api.js";
 import { BitmapIndex } from "../bitmap.js";
+import { __columnError } from "../internal/checks.js";
+import { __clamp } from "../internal/indexof.js";
 class AColumn {
   constructor(id, table) {
     this.id = id;
@@ -16,6 +17,24 @@ class AColumn {
   reindex() {
     this.updateBitmap();
   }
+  findIndex(pred, start = 0, end) {
+    const max = this.table.length - 1;
+    start = __clamp(start, 0, max);
+    end = __clamp(end ?? max, 0, max);
+    for (let i = start; i <= end; i++) {
+      if (pred(this.getRow(i))) return i;
+    }
+    return -1;
+  }
+  findLastIndex(pred, start = 0, end) {
+    const max = this.table.length - 1;
+    start = __clamp(start, 0, max);
+    end = __clamp(end ?? max, 0, max);
+    for (let i = end; i >= start; i--) {
+      if (pred(this.getRow(i))) return i;
+    }
+    return -1;
+  }
   encode(value) {
     return value;
   }
@@ -49,7 +68,7 @@ class AColumn {
     }
   }
   ensureValue(val) {
-    return val != null ? val : this.spec.cardinality[0] > 0 ? this.spec.default ?? illegalArgs(`missing value for column: ${this.id}`) : this.spec.default ?? null;
+    return val != null ? val : this.spec.cardinality[0] > 0 ? this.spec.default ?? __columnError(this.id, `missing value`) : this.spec.default ?? null;
   }
   ensureBitmap() {
     if (this.spec.flags & FLAG_BITMAP) this.bitmap = new BitmapIndex();

package/columns/dict-tuple.d.ts

@@ -1,7 +1,7 @@
 import { BidirIndex } from "@thi.ng/bidir-index";
-import { type IColumn, type SerializedColumn } from "../api.js";
+import { type Row, type SerializedColumn } from "../api.js";
 import { AColumn } from "./acolumn.js";
-export declare class DictTupleColumn extends AColumn implements IColumn {
+export declare class DictTupleColumn<T extends Row = Row> extends AColumn<T> {
     values: (number[] | null)[];
     dict: BidirIndex<any>;
     readonly isArray = true;

package/columns/dict.d.ts

@@ -1,7 +1,7 @@
 import { BidirIndex } from "@thi.ng/bidir-index";
-import { type IColumn, type SerializedColumn } from "../api.js";
+import { type Row, type SerializedColumn } from "../api.js";
 import { AColumn } from "./acolumn.js";
-export declare class DictColumn extends AColumn implements IColumn {
+export declare class DictColumn<T extends Row = Row> extends AColumn<T> {
     values: (number | null)[];
     dict: BidirIndex<any>;
     readonly isArray = false;

package/columns/plain.d.ts

@@ -1,6 +1,6 @@
-import { type IColumn, type SerializedColumn } from "../api.js";
+import { type Row, type SerializedColumn } from "../api.js";
 import { AColumn } from "./acolumn.js";
-export declare class PlainColumn extends AColumn implements IColumn {
+export declare class PlainColumn<T extends Row = Row> extends AColumn<T> {
     values: any[];
     readonly isArray = false;
     load({ values }: SerializedColumn): void;

package/columns/tuple.d.ts

@@ -1,7 +1,7 @@
 import type { Nullable } from "@thi.ng/api";
-import { type IColumn, type SerializedColumn } from "../api.js";
+import { type Row, type SerializedColumn } from "../api.js";
 import { AColumn } from "./acolumn.js";
-export declare class TupleColumn extends AColumn implements IColumn {
+export declare class TupleColumn<T extends Row = Row> extends AColumn<T> {
     values: Nullable<number[]>[];
     readonly isArray = true;
     load(spec: SerializedColumn): void;

package/columns/typedarray.d.ts

@@ -1,14 +1,14 @@
 import { type TypedArray } from "@thi.ng/api/typedarray";
-import { type IColumn, type NumericType, type SerializedColumn } from "../api.js";
+import { type ColumnID, type NumericType, type Row, type SerializedColumn } from "../api.js";
 import type { Table } from "../table.js";
 import { AColumn } from "./acolumn.js";
-export declare class TypedArrayColumn extends AColumn implements IColumn {
+export declare class TypedArrayColumn<T extends Row = Row> extends AColumn<T> {
     values: TypedArray;
     type: NumericType;
     limit: [number, number];
     protected tmp: TypedArray;
     readonly isArray = false;
-    constructor(id: string, table: Table);
+    constructor(id: ColumnID<T>, table: Table<T>);
     load({ values }: SerializedColumn): void;
     validate(value: any): boolean;
     setRow(i: number, value: any): void;

package/columns/vector.d.ts

@@ -1,19 +1,19 @@
 import { type TypedArray } from "@thi.ng/api/typedarray";
-import { type IColumn, type NumericType, type SerializedColumn } from "../api.js";
+import { type ColumnID, type NumericType, type Row, type SerializedColumn } from "../api.js";
 import type { Table } from "../table.js";
 import { AColumn } from "./acolumn.js";
-export declare class VectorColumn extends AColumn implements IColumn {
+export declare class VectorColumn<T extends Row = Row> extends AColumn<T> {
     values: TypedArray;
     type: NumericType;
     size: number;
     limit: [number, number];
     protected tmp: TypedArray;
     readonly isArray = false;
-    constructor(id: string, table: Table);
+    constructor(id: ColumnID<T>, table: Table<T>);
     load({ values }: SerializedColumn): void;
     validate(value: any): boolean;
     setRow(i: number, value: any): void;
-    getRow(i: number): Float32Array<ArrayBufferLike> | Float64Array<ArrayBufferLike> | Int8Array<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Uint8ClampedArray<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike>;
+    getRow(i: number): Uint32Array<ArrayBufferLike> | Float32Array<ArrayBufferLike> | Float64Array<ArrayBufferLike> | Int8Array<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Uint8ClampedArray<ArrayBufferLike> | Uint16Array<ArrayBufferLike>;
     getRowKey(i: number): string;
     valueKey(value: any): string | string[];
     removeRow(i: number): void;

package/columns/vector.js

@@ -77,6 +77,7 @@ class VectorColumn extends AColumn {
     this.bitmap?.removeBit(i);
   }
   indexOf(value, start = 0, end = this.table.length) {
+    if (value == null) return -1;
     const { values, bitmap, size } = this;
     start = Math.max(start, 0);
     end = Math.min(end, this.table.length);

package/internal/indexof.d.ts

@@ -2,5 +2,8 @@ import type { Maybe } from "@thi.ng/api";
 import type { BitmapIndex } from "../bitmap.js";
 /** @internal */
 export declare const __indexOfSingle: (needle: any, values: ArrayLike<any>, bitmap: Maybe<BitmapIndex>, max: number, start: number, end?: number) => number;
+/** @internal */
 export declare const __indexOfTuple: (needle: ArrayLike<any> | null, values: ArrayLike<any>, max: number, start: number, end?: number) => number;
+/** @internal */
+export declare const __clamp: (x: number, a: number, b: number) => number;
 //# sourceMappingURL=indexof.d.ts.map

package/internal/indexof.js

@@ -1,6 +1,6 @@
 const __indexOfSingle = (needle, values, bitmap, max, start, end = max) => {
-  start = Math.max(start, 0);
-  end = Math.min(end, max);
+  start = __clamp(start, 0, max);
+  end = __clamp(end, 0, max);
   if (bitmap) return bitmap.index.get(needle)?.first(start, end) ?? -1;
   for (let i = start; i < end; i++) {
     if (values[i] === needle) return i;
@@ -8,12 +8,13 @@ const __indexOfSingle = (needle, values, bitmap, max, start, end = max) => {
   return -1;
 };
 const __indexOfTuple = (needle, values, max, start, end = max) => {
-  start = Math.max(start, 0);
-  end = Math.min(end, max);
+  start = __clamp(start, 0, max);
+  end = __clamp(end, 0, max);
   if (needle == null) {
     for (let i2 = start; i2 < end; i2++) {
       if (!values[i2]) return i2;
     }
+    return -1;
   }
   const n = needle.length;
   let i, j, row;
@@ -28,7 +29,9 @@ const __indexOfTuple = (needle, values, max, start, end = max) => {
   }
   return -1;
 };
+const __clamp = (x, a, b) => x < a ? a : x > b ? b : x;
 export {
+  __clamp,
   __indexOfSingle,
   __indexOfTuple
 };

package/internal/serialize.d.ts

@@ -11,5 +11,5 @@ export declare const __serializeTyped: ($values: NumericArray, spec: ColumnSpec,
     values: any[];
 };
 /** @internal */
-export declare const __deserializeTyped: (type: Type, flags: number, values: number[]) => Float32Array<ArrayBufferLike> | Float64Array<ArrayBufferLike> | Int8Array<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Uint8ClampedArray<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | Uint32Array<ArrayBufferLike>;
+export declare const __deserializeTyped: (type: Type, flags: number, values: number[]) => Uint32Array<ArrayBufferLike> | Float32Array<ArrayBufferLike> | Float64Array<ArrayBufferLike> | Int8Array<ArrayBufferLike> | Int16Array<ArrayBufferLike> | Int32Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | Uint8ClampedArray<ArrayBufferLike> | Uint16Array<ArrayBufferLike>;
 //# sourceMappingURL=serialize.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@thi.ng/column-store",
-	"version": "0.4.0",
+	"version": "0.5.1",
 	"description": "In-memory column store database with customizable column types, extensible query engine, bitfield indexing for query acceleration, JSON serialization with optional RLE compression",
 	"type": "module",
 	"module": "./index.js",
@@ -44,7 +44,7 @@
 		"@thi.ng/bidir-index": "^1.5.0",
 		"@thi.ng/checks": "^3.8.4",
 		"@thi.ng/errors": "^2.6.3",
-		"@thi.ng/rle-pack": "^3.2.0"
+		"@thi.ng/rle-pack": "^3.2.1"
 	},
 	"devDependencies": {
 		"esbuild": "^0.27.2",
@@ -126,5 +126,5 @@
 		"status": "alpha",
 		"year": 2025
 	},
-	"gitHead": "5c620a1aa00535cc7c674794790edd87b2e5e526\n"
+	"gitHead": "34b762e0eeaf54adf4a879843a96a53e5e59d6d1\n"
 }

package/query.d.ts

@@ -1,30 +1,33 @@
 import type { Predicate } from "@thi.ng/api";
-import type { QueryTerm, QueryTermOpSpec } from "./api.js";
+import type { ColumnID, QueryTerm, QueryTermOpSpec, Row } from "./api.js";
 import type { Table } from "./table.js";
-export declare class Query {
-    table: Table;
-    terms: QueryTerm[];
-    constructor(table: Table, terms?: QueryTerm[]);
-    addTerm(term: QueryTerm): this;
+export declare class Query<T extends Row> {
+    readonly table: Table<T>;
+    terms: QueryTerm<T>[];
+    constructor(table: Table<T>, terms?: QueryTerm<T>[]);
+    addTerm(term: QueryTerm<T>): this;
     /** Alias for {@link Query.or} */
-    where: (column: string, value: any) => this;
+    where: (column: ColumnID<T>, value: any) => this;
     /** Alias for {@link Query.nor} */
-    whereNot: (column: string, value: any) => this;
-    or(column: string, value: any): this;
-    nor(column: string, value: any): this;
-    and(column: string, value: any): this;
-    nand(column: string, value: any): this;
-    matchColumn(column: string, pred: Predicate<any>): this;
-    matchPartialRow(columns: string[], pred: Predicate<Record<string, any>>): this;
-    matchRow(pred: Predicate<Record<string, any>>): this;
-    [Symbol.iterator](): Generator<import("./api.js").Row | undefined, void, unknown>;
+    whereNot: (column: ColumnID<T>, value: any) => this;
+    or(column: ColumnID<T>, value: any): this;
+    nor(column: ColumnID<T>, value: any): this;
+    and(column: ColumnID<T>, value: any): this;
+    nand(column: ColumnID<T>, value: any): this;
+    matchColumn(column: ColumnID<T>, pred: Predicate<any>): this;
+    matchPartialRow<K extends ColumnID<T>>(columns: K[], pred: Predicate<Pick<T, K>>): this;
+    matchRow(pred: Predicate<T>): this;
+    valueRange(column: ColumnID<T>, start: any, end?: any): this;
+    rowRange(start?: number, end?: number): this;
+    [Symbol.iterator](): Generator<import("./api.js").RowWithMeta<T>, void, unknown>;
 }
-export declare class QueryCtx {
-    readonly query: Query;
-    readonly table: Table;
+export declare class QueryCtx<T extends Row> {
+    readonly query: Query<T>;
+    readonly table: Table<T>;
     readonly size: number;
     bitmap?: Uint32Array;
-    constructor(query: Query);
+    constructor(query: Query<T>);
+    clear(): void;
     makeMask(seed?: Uint32Array): Uint32Array<ArrayBuffer>;
     /**
      * Combines the `mask` with the context's mask (combined using bitwise AND).

package/query.js

@@ -2,6 +2,8 @@ import { isArray } from "@thi.ng/checks/is-array";
 import { illegalArgs } from "@thi.ng/errors/illegal-arguments";
 import { unsupportedOp } from "@thi.ng/errors/unsupported";
 import { Bitfield } from "./bitmap.js";
+import { __columnError } from "./internal/checks.js";
+import { __clamp } from "./internal/indexof.js";
 class Query {
   constructor(table, terms = []) {
     this.table = table;
@@ -49,6 +51,19 @@ class Query {
     this.terms.push({ type: "matchRow", value: pred });
     return this;
   }
+  valueRange(column, start, end) {
+    if (this.table.columns[column].isArray)
+      __columnError(
+        column,
+        `operator not supported with this column type`
+      );
+    this.terms.push({ type: "valueRange", column, value: { start, end } });
+    return this;
+  }
+  rowRange(start = 0, end) {
+    this.terms.push({ type: "rowRange", value: { start, end } });
+    return this;
+  }
   *[Symbol.iterator]() {
     const { table } = this;
     const ctx = new QueryCtx(this);
@@ -57,7 +72,7 @@ class Query {
       let column;
       if (term.column) {
         column = ctx.table.columns[term.column];
-        if (!column) illegalArgs(`column: ${term.column}`);
+        if (!column) illegalArgs(`column: ${String(term.column)}`);
       } else if (QUERY_OPS[term.type].mode !== "row") {
         illegalArgs(
           `query op: ${term.type} requires a column name given`
@@ -80,6 +95,9 @@ class QueryCtx {
   table;
   size;
   bitmap;
+  clear() {
+    this.bitmap = void 0;
+  }
   makeMask(seed) {
     const mask = new Uint32Array(this.size);
     if (seed) mask.set(seed);
@@ -174,7 +192,7 @@ const execBitAnd = (ctx, term, column) => {
     for (let k of key) {
       const b = bitmap.index.get(k)?.buffer;
       if (!b) {
-        if (term.type === "and") ctx.bitmap = void 0;
+        if (term.type === "and") ctx.clear();
         return;
       }
       colBitmaps.push(b);
@@ -191,9 +209,7 @@ const execBitAnd = (ctx, term, column) => {
   }
   if (mask) {
     term.type === "nand" ? ctx.mergeInvMask(mask) : ctx.mergeMask(mask);
-  } else {
-    ctx.bitmap = void 0;
-  }
+  } else ctx.clear();
 };
 const execAnd = (ctx, term, column) => {
   const n = ctx.table.length;
@@ -213,7 +229,7 @@ const execAnd = (ctx, term, column) => {
         for (let i = 0; i < n; i++) mask[i] &= m[i];
       } else mask = m;
     } else {
-      if (term.type === "and") ctx.bitmap = void 0;
+      if (term.type === "and") ctx.clear();
       return;
     }
   }
@@ -253,7 +269,7 @@ const QUERY_OPS = {
       const columns = term.params;
       const pred = term.value;
       let mask;
-      for (let i = 0, n = ctx.table.length; i < n; i++) {
+      for (let i = 0, n = table.length; i < n; i++) {
         if (pred(table.getPartialRow(i, columns, false))) {
           if (!mask) mask = ctx.makeMask();
           mask[i >>> 5] |= 1 << (i & 31);
@@ -268,7 +284,7 @@ const QUERY_OPS = {
       const table = ctx.table;
       const pred = term.value;
       let mask;
-      for (let i = 0, n = ctx.table.length; i < n; i++) {
+      for (let i = 0, n = table.length; i < n; i++) {
         if (pred(table.getRow(i, false))) {
           if (!mask) mask = ctx.makeMask();
           mask[i >>> 5] |= 1 << (i & 31);
@@ -276,6 +292,42 @@ const QUERY_OPS = {
       }
       if (mask) ctx.mergeMask(mask);
     }
+  },
+  valueRange: {
+    fn: (ctx, term, column) => {
+      const max = ctx.table.length;
+      const { start, end } = term.value;
+      let $start = 0;
+      let $end = max;
+      if (start != null) $start = column.findIndex((x) => x >= start);
+      if (end != null)
+        $end = column.findLastIndex((x) => x <= end, $start);
+      if ($start >= 0 && $end >= 0) {
+        const mask = ctx.makeMask();
+        const bitmap = new Bitfield(mask);
+        bitmap.fill(
+          1,
+          $start >= 0 ? $start : 0,
+          $end >= 0 ? $end + 1 : max
+        );
+        ctx.mergeMask(mask);
+      } else ctx.clear();
+    }
+  },
+  rowRange: {
+    mode: "row",
+    fn: (ctx, term) => {
+      const max = ctx.table.length;
+      let { start = 0, end = max } = term.value;
+      start = __clamp(start, 0, max);
+      end = __clamp(end, 0, max);
+      if (start >= 0 && end >= 0) {
+        const mask = ctx.makeMask();
+        const bitmap = new Bitfield(mask);
+        bitmap.fill(1, start, end);
+        ctx.mergeMask(mask);
+      } else ctx.clear();
+    }
   }
 };
 const registerQueryOp = (type, spec) => {

package/table.d.ts

@@ -1,38 +1,43 @@
-import { type ColumnSchema, type ColumnSpec, type ColumnTypeSpec, type IColumn, type QueryTerm, type Row, type SerializedTable } from "./api.js";
+import type { Maybe } from "@thi.ng/api";
+import { type ColumnID, type ColumnSchema, type ColumnSpec, type ColumnTypeSpec, type IColumn, type QueryTerm, type Row, type RowWithMeta, type SerializedTable } from "./api.js";
 import { Query } from "./query.js";
 /**
  * Placeholder only. Unused so far.
  */
 export interface TableOpts {
 }
-export declare class Table {
+export declare class Table<T extends Row> {
     opts: TableOpts;
-    schema: ColumnSchema;
-    columns: Record<string, IColumn>;
+    schema: ColumnSchema<T>;
+    columns: Record<ColumnID<T>, IColumn>;
     length: number;
-    static load(serialized: SerializedTable, opts?: Partial<TableOpts>): Table;
-    constructor(schema: Record<string, Partial<ColumnSpec> & {
+    static load<T extends Row>(serialized: SerializedTable<T>, opts?: Partial<TableOpts>): Table<T>;
+    constructor(schema: Record<ColumnID<T>, Partial<ColumnSpec> & {
         type: ColumnSpec["type"];
     }>, opts?: Partial<TableOpts>);
-    query(terms?: QueryTerm[]): Query;
-    addColumn(id: string, spec: Partial<ColumnSpec> & {
+    query(terms?: QueryTerm<T>[]): Query<T>;
+    addColumn(id: ColumnID<T>, spec: Partial<ColumnSpec> & {
         type: ColumnSpec["type"];
     }): void;
-    removeColumn(id: string): boolean;
-    [Symbol.iterator](): Generator<Row | undefined, void, unknown>;
+    removeColumn(id: ColumnID<T>): boolean;
+    [Symbol.iterator](): Generator<Maybe<T>, void, unknown>;
     reindex(): void;
-    addRow(row: Row): void;
-    addRows(rows: Iterable<Row>): void;
-    updateRow(i: number, row: Row): void;
+    addRow(row: Partial<T>): void;
+    addRows(rows: Iterable<Partial<T>>): void;
+    updateRow(i: number, row: T): void;
     removeRow(i: number): void;
-    getRow(i: number, safe?: boolean, includeID?: boolean): Row | undefined;
-    getPartialRow(i: number, columns: string[], safe?: boolean, includeID?: boolean): Row | undefined;
-    indexOf(id: string, value: any, start?: number, end?: number): number;
-    validateRow(row: Row): void;
-    validateColumnSpec(id: string, spec: ColumnSpec): void;
+    getRow(i: number, safe?: boolean): Maybe<T>;
+    getRow(i: number, safe?: boolean, includeID?: false): Maybe<T>;
+    getRow(i: number, safe?: boolean, includeID?: true): Maybe<RowWithMeta<T>>;
+    getPartialRow<K extends ColumnID<T>>(i: number, columns: K[], safe?: boolean): Maybe<Pick<T, K>>;
+    getPartialRow<K extends ColumnID<T>>(i: number, columns: K[], safe?: boolean, includeID?: false): Maybe<Pick<T, K>>;
+    getPartialRow<K extends ColumnID<T>>(i: number, columns: K[], safe?: boolean, includeID?: true): Maybe<RowWithMeta<Pick<T, K>>>;
+    indexOf(id: ColumnID<T>, value: any, start?: number, end?: number): number;
+    validateRow(row: Partial<T>): void;
+    validateColumnSpec(id: ColumnID<T>, spec: ColumnSpec): void;
     toJSON(): {
-        schema: ColumnSchema;
-        columns: Record<string, IColumn>;
+        schema: ColumnSchema<T>;
+        columns: Record<ColumnID<T>, IColumn>;
         length: number;
     };
 }

package/table.js

@@ -43,7 +43,11 @@ class Table {
     };
     this.validateColumnSpec(id, $spec);
     this.schema[id] = $spec;
-    this.columns[id] = COLUMN_TYPES[spec.type].impl(this, id, $spec);
+    this.columns[id] = COLUMN_TYPES[spec.type].impl(
+      this,
+      String(id),
+      $spec
+    );
   }
   removeColumn(id) {
     if (this.columns[id]) return false;