Example Workloads#

Aggregation functions (sum, avg, min, max, count, distinct)

Read/write anomaly patterns (lost update, stale read, write skew) for isolation level testing

Bank account operations for contention and correctness testing

query_batch and exec_batch query types for batch inserts and updates

Binary data with blob() (all databases) and bytes() (PostgreSQL/CockroachDB)

Find the point at which a database degrades under increasing load with edg perf breakpoint

Capture seed query results for use in run queries via ref functions

Cassandra (CQL) with keyspaces, tables, batch inserts, and reference data

Mixed OLTP+OLAP workload combining TPC-C transactions with TPC-H-style analytical queries

Distributed coordination of multiple edg agents, supporting massive throughput workloads

Compare two databases side-by-side

LLM structured text generation using tool calling for product reviews with sentiment and ratings

LLM batch generation to produce multiple structured items in a single API call with complete_array

PostgreSQL/CockroachDB composite types (CREATE TYPE ... AS (...)) with ROW(...)::type construction

Binary conditional branching with if/then/else for market-specific GDPR checks and tax rules

Multi-way dispatch with match/when/default for region-specific compliance checks

Concurrency anomaly stress test (dirty reads, phantoms, write skew, lost updates) with EDG_NO_ATOMIC_TX toggle

Multi-table temporal patterns with shared signals - tables track a common time-varying pattern with configurable lag and correlation

Loading CSV files as reference datasets via --csv-file and --csv-directory flags

All five distribution functions (uniform, zipf, norm_f, exp_f, lognorm_f)

E-commerce with categories, products, customers, and orders

Cartesian product seeding with ref_each across multiple tables

Real vector embeddings via external API for semantic similarity search (OpenAI-compatible)

Fetching and using environment variables in workload configs

Mutually exclusive columns - either col_a or col_b, never both

Post-run assertions for CI/CD gating on error rate, latency, and throughput

expr-lang built-in features (array, map, string, bitwise, etc.)

Map lookup with fail() to validate environment variables and stop workers on unknown values

Dating app workload with location-based discovery (ST_DWithin, GiST index), swipes, matches, and messaging

Globally unique auto-incrementing sequences shared across all workers with seq_global

Sharing declarations across .edg files with import and pub for modular configs

Splitting and reusing config fragments with the !include directive

Comparison test using expectations to assert indexed lookups outperform unindexed (avg and p99 latency)

Generate edg config files from existing database schemas with edg init

Correlated parent-child data with distribute_sum() and distribute_weighted() for totals that always balance

IoT devices, sensors, and time-series readings

Batch insert referencing another table, without buffering it into memory like ref_each

Locale-aware PII generation (gen_locale) with deterministic masking (mask) across JP and DE regions

Hierarchical org chart using PostgreSQL's ltree extension with ltree() path builder

Starter workload for building familiarity with edg (create, seed, read, update, cleanup)

MongoDB with BSON/JSON command syntax, collection operations, and reference data

__values__ token for cross-driver multi-row INSERT, UPSERT, and UPDATE

Map-style args with arg('name') instead of arg(0)

Product reviews with normal distribution ratings

nullable(expr, probability) for injecting NULLs with controlled frequency

Reusable arg templates with the objects config section, shared across seed and run queries

Prometheus metrics and Grafana dashboard with queries, writes, and rollback-prone transactions

Hierarchical org chart (CEO -> VPs -> Directors -> Managers -> ICs) using seed capture for self-referential generation

stage command output formats (SQL, JSON, CSV, Parquet, stdout) without a database connection

Multi-table sequential reads and writes

WASM plugins for custom data generation functions (Go, Rust, Zig examples)

Billion-row data population benchmark

Prepared statements for reduced parse overhead in high-throughput workloads

Live aggregated stats with print expressions (frequency, min/avg/max, custom agg)

Static reference datasets without database queries

Load a workload config from an HTTP/HTTPS URL instead of a local file

Multi-tenant SaaS with tenants, users, projects, and tasks

Airline reservation system benchmark with flight booking contention

Per-worker and global numeric/alpha auto-incrementing sequences for unique identifiers

Run edg as an HTTP server to submit and stream workload jobs via REST API

Social network with users, posts, follows, and tags

Staged execution with different worker counts and durations per phase

Stages with QPS rate limiting to control throughput at each phase of a workload

Per-stage run_weights overrides to shift the workload mix alongside worker count

Dual-write consistency testing across databases (CockroachDB + MySQL) with batched verification

Pure insert micro-benchmark (oltp_insert) for ingestion throughput

Pure point-select micro-benchmark (oltp_point_select) for read latency

Mixed read-write micro-benchmark (oltp_read_write) with scans, updates, and deletes

Pure indexed-column update micro-benchmark (oltp_update_index)

Telecom Application Transaction Processing benchmark (80% reads, 20% writes)

Data drift over time using global_iter() - Zipf skew drift, logarithmic growth, sine wave seasonality, periodic spikes, and bounded arctangent saturation

Monotonically incrementing timestamps aligned to intervals or evenly spaced across date ranges

Full TPC-C benchmark with all 5 transaction profiles

Multi-statement transactions with read-then-write patterns (SQL, MongoDB sessions, Cassandra logged batches)

Declarative hierarchical and DAG generation using tree/levels config for org charts and dependency graphs

pgvector-compatible embeddings with clustered vectors for similarity search

Delayed one-shot worker that applies schema changes mid-run (e.g., adding an index after 30s)

Background worker queries on a fixed schedule alongside the main run loop (job queue with lease expiry)

Built-in workloads (bank, ch, kv, movr, seats, sysbench, tatp, tpcc, tpch, ycsb) without a config file

Yahoo! Cloud Serving Benchmark with a single usertable and configurable workload profiles