fastdb4py 0.1.14

FastCarto database bindings

fastdb

fastdb is a C++ local database library designed as a fast, lightweight, and easy-to-use data communication layer for RPC and coupled modeling in scientific computing.

This repository now contains three closely related layers:

• C++ core — native storage engine, binary layout, and serialization primitives
• fastdb4py — Python bindings via SWIG, with NumPy-oriented columnar access and shared-memory IPC
• fastdb4ts — TypeScript bindings via WebAssembly/Embind, focused on browser-friendly typed data access and serializer compatibility

Core design goals:

• Zero-copy columnar access — efficient field-oriented access for high-volume numerical workloads
• Ref-graph support — Features can reference other Features across tables, forming typed object graphs
• Compact binary transport — save/load databases as binary buffers or files
• Cross-binding consistency — Python and TypeScript bindings share the same native storage model and serializer semantics
• Schema-driven codegen — Python Feature classes serve as the single source of truth; the fdb codegen CLI generates equivalent TypeScript schemas automatically

Documentation map

• Python binding (fastdb4py): see python/README.md
• TypeScript binding (fastdb4ts): see ts/README.md
• C++ core (fastcarto/fastdb): see fastcarto/README.md
• TypeScript/WASM analysis docs: see ts/analysis/
• Codegen CLI (fdb codegen): see CLI tools below, or the full reference in python/README.md

Changelog

See CHANGELOG.md for per-binding unreleased changes.
For historical release notes, see the GitHub Releases page.

Installation

Python binding (fastdb4py)

pip install fastdb4py

TypeScript binding (fastdb4ts)

npm install fastdb4ts

Quick start

For a minimal end-to-end example, start with:

• python/README.md for fastdb4py
• ts/README.md for fastdb4ts

If you are working on native internals or storage layout, start with:

• fastcarto/README.md

CLI tools

fastdb4py ships a CLI named fdb for cross-language tooling. Currently it provides the codegen subcommand.

fdb codegen — Python → TypeScript schema generator

Generate TypeScript Feature classes from a directory of Python feature definitions:

fdb codegen --ts ./python_features/ ./ts_features/

This mirrors the input directory structure, generating one .ts file per .py file. Each Python Feature subclass becomes a TypeScript class with defineSchema(...) and declare fields.

Features:

• All scalar types (U8–F64, STR, WSTR, BYTES, BOOL) and native Python types (int, float, str, bool) are mapped automatically
• Feature references → ref(ClassName), lists of Features → listOf(ref(ClassName))
• Circular/self-referential types → lazy refs ref(() => ClassName) detected automatically
• Cross-file dependencies → relative import statements in the generated TypeScript
• Topological ordering ensures dependency classes are emitted before dependents
• Same class name in different files is legal — each file is an independent module, all are generated

Example input (geometry.py):

from fastdb4py import Feature, F64, STR

class Point(Feature):
    x: F64
    y: F64
    label: STR

Generated output (geometry.ts):

import { F64, Feature, STR, defineSchema } from 'fastdb4ts';

export class Point extends Feature {
  static schema = defineSchema({
    x: F64,
    y: F64,
    label: STR,
  });
  declare x: number;
  declare y: number;
  declare label: string;
}

Performance Notes

Pattern	Throughput	Notes
table.column.x[:] columnar read/write	~100 ns for any N	Zero-copy NumPy view, 1 SWIG call
Table.fill(field, array)	~2 µs per column	1 SWIG call + memcpy
feature.read_all_scalars()	~200 ns for 3 fields	1 SWIG call for all scalar fields
table.iter_reuse() row access	~350 ns/row	Reuses Feature wrapper, no allocation
for feat in table row access	~1.2 µs/row	Allocates Feature wrapper per row
feat.x single field read (db-mapped)	~420 ns	1 SWIG call

Recommended patterns by use case:

• Bulk read/write of one field across all rows → table.column.x (columnar, zero-copy)
• Bulk fill all fields from arrays → ORM.truncate + table.column.field[:] = array
• Iterate and process all fields per row → table.iter_reuse() + feat.read_all_scalars()
• Sparse random access → table[i].field

Development

This project uses DevContainer for the development environment. See .devcontainer/devcontainer.example.json for configuration details. Requires Docker/Podman and the VSCode DevContainer extension.

Common development commands from the repository root:

./py_utils.sh --clean   # remove C++ build artifacts and SWIG-generated bindings
./py_utils.sh --build   # build C++ core + Python bindings
./py_utils.sh --test    # run Python unit tests
bash ts/build-wasm.sh   # build the WebAssembly module for fastdb4ts
npm run test:ts         # run root TypeScript tests
fdb codegen --ts <input_dir> <output_dir>  # generate TypeScript schemas from Python features

Build requirements depend on the layer you are working on:

• Python binding: C++17 compiler, CMake >= 3.16, SWIG >= 4.0, NumPy
• TypeScript/WASM binding: Emscripten, Node.js, npm
• Native core: C++17 compiler and CMake