rust-sqlite-ingestor-low-ram

Ingest large JSONL log files into SQLite with low-RAM live mode.

2|Updated Jan 30, 2026
One-click install
npx skills add https://github.com/tankygranny05/agent-box --skill rust-sqlite-ingestor-low-ram
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: rust-sqlite-ingestor-low-ram
Source: https://github.com/tankygranny05/agent-box/tree/main/agent-box/seed/codex-skills/rust-sqlite-ingestor-low-ram
Command: npx skills add https://github.com/tankygranny05/agent-box --skill rust-sqlite-ingestor-low-ram

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires memchr, rusqlite, clap, anyhow, libc, sysinfo, ahash, and includes references (resource) and scripts (resource) components.

What problem does it solve?

This Skill addresses the challenge of ingesting massive JSONL log files into SQLite databases efficiently, particularly under strict memory constraints during live operation.

Core Features & Use Cases

  • High-Throughput Ingestion: Optimized for ingesting huge JSONL logs at high speeds in historical mode.
  • Low RAM Live Mode: Enforces a strict RSS budget in live mode using advanced parsing and SQLite tuning.
  • Efficient Parsing: Utilizes byte-scan parsing instead of full JSON parsing to minimize overhead.
  • Mode-Specific Tuning: Employs different SQLite PRAGMAs for historical (speed) and live (low-RAM) modes.
  • Reliable Transitions: Supports robust historical-to-live transitions, including process restarts via exec().
  • Use Case: Ingesting real-time event streams into a SQLite database while maintaining a minimal memory footprint for long-running applications.

Quick Start

Use the rust-sqlite-ingestor-low-ram skill to ingest the file 'events.jsonl' into 'events.db' in live mode.

Frequently Asked Questions about rust-sqlite-ingestor-low-ram

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I ingest large JSONL log files into SQLite without running out of RAM?

You can ingest large JSONL files into SQLite under a strict memory budget by using byte-scan parsing instead of full JSON parsing, combined with mode-specific SQLite PRAGMAs to enforce a strict RSS limit during live operation.

What is the best way to parse JSONL streams for SQLite ingestion at high throughput?

The best way for high-throughput JSONL ingestion is using a historical mode with byte-scan parsing and tuned SQLite PRAGMAs. This avoids full JSON parsing overhead, maximizing ingestion speed for massive log files.

Can I use Rust and rusqlite for low-memory SQLite ingestion?

Yes, you can use Rust with rusqlite for low-memory SQLite ingestion. This Skill uses rusqlite alongside byte-scan parsing and memory monitoring via sysinfo and libc to enforce a strict RSS budget in live mode.

How does live mode handle memory limits when ingesting JSONL data?

Live mode handles memory limits by enforcing a strict RSS budget using advanced parsing techniques and specific SQLite PRAGMAs. It also supports reliable historical-to-live transitions through process restarts via exec().

Does this JSONL to SQLite ingestor support transitioning from high-speed bulk loading to live streaming?

Yes, the ingestor supports reliable historical-to-live transitions. It uses a high-speed historical mode for bulk loading and transitions to a strict low-RAM live mode using process restarts via exec() for efficient data processing.