tonsky/datascript
Datascript
Datascript is an immutable, in-memory state store and schema-based triple store. It manages application state as a versioned database, storing data as immutable facts consisting of an entity, attribute, value, and transaction.
The project provides a logic engine for executing Datalog queries with support for implicit joins, recursive rules, and negation. It also features a declarative pull API for retrieving deeply nested entity graphs and related data structures.
The database enforces data integrity through schema-driven constraints and attribute types. It supports atomic transactions, pluggable storage protocols for persistence, and B-tree attribute indexing to optimize lookups.
The system is designed for use within Clojure, ClojureScript, and JavaScript environments.
Features
- Triple Stores - Implements a schema-based triple store using an EAVT model for flexible data representation.
- Logic-Based Relational Querying - Provides a logic-based relational query engine using Datalog paradigms for Clojure and JavaScript environments.
- Triple Stores - Implements a schema-based triple store using an EAVT model to manage immutable facts.
- Nested Entity Retrieval - Extracts related data using a pull API that supports recursive exploration of entity graphs.
- Application State Management - Provides centralized application state management using an immutable in-memory data store.
- Schema-Enforced Triple Stores - Combines a triple store architecture with schema-driven constraints to ensure data integrity and optimize indexing.
- Declarative Pull APIs - Provides a declarative pull API for retrieving deeply nested entity graphs and related data.
- In-Memory Data Stores - Provides a high-performance in-memory data store for managing ephemeral application state.
- In-Memory State Stores - Maintains application state in an immutable in-memory store to ensure low-latency interaction.
- Logic Query Engines - Provides a logic query engine using Datalog to resolve complex data relationships through recursive rules and negation.
- Entity Graph Fetching - Implements a declarative pull API to retrieve deeply nested entity graphs and related data structures.
- Datalog Recursive Rules - Uses a Datalog engine to execute complex lookups including recursive rules and transitive closures.
- Complex Search Querying - Supports advanced querying of application state using negation, disjunction, and recursive rules.
- Graph Pull APIs - Offers a declarative pull API for extracting deeply nested entity graphs and customized result shapes.
- Immutable Data Storage - Treats data as immutable values to create new database versions while preserving older ones.
- Datomic-Style Immutable Stores - Implements a Datomic-style immutable store allowing for time-travel queries and consistent state snapshots.
- EAVT Triple Stores - Implements a versioned database using an immutable EAVT (Entity-Attribute-Value-Transaction) triple store model.
- Transactional State Versioning - Treats all data changes as additive to maintain a history of database snapshots via transactional state versioning.
- Schema-Based Data Models - Enforces data integrity and lookup performance via schema-driven attribute types and unique identity constraints.
- Atomic Transaction Execution - Supports grouping database updates into atomic transactions to ensure data consistency.
- Database Schema Constraints - Enforces data integrity and lookup performance through defined attribute types and unique identity constraints.
- Schema Querying - Allows finding entities that match specific attribute configurations by treating the schema definition as a queryable collection.
- Database Transactions - Updates database state through atomic transactions supporting upserts and custom functions.
- Custom Storage Implementations - Provides a protocol to route database reads and writes to custom external storage backends.
- Pluggable Storage Engines - Decouples the in-memory database from the persistence layer through a pluggable storage engine interface.
- B-Tree - Implements B-Tree attribute indexing to optimize value lookups and range queries within the state store.
- B+ Tree Indexing - Utilizes B-tree indexing to speed up attribute lookups and range queries.
- Incremental State Persistence - Minimizes storage overhead by persisting only modified portions of the database to the backend.
- JavaScript Interoperability - Integrates with JavaScript engines to allow queries and transactions using standard arrays and objects.
- Schema-Driven Validations - Validates data integrity and optimizes indexing by applying attribute types and uniqueness rules during transactions.
- State Evolution Tracking - Records database changes to enable rewinding state and maintaining consistent snapshots.
- Databases and Persistence - In-memory database and Datalog query engine.
- Databases & Data - Immutable in-memory database with Datalog query capabilities.
