Breaking Database Lock-in: Agentic Regeneration of High Performance Storage Readers for Database Bypass

Method§

Jailbreak leverages Large Language Models (LLMs) to synthesize customized storage readers for analytical workloads. The key idea is to treat database file formats as code-specified artifacts: the LLM ingests the source code and documentation of PostgreSQL or MySQL storage engines, and generates C code that directly reads raw data files (e.g., heap pages) and materializes columns into Apache Arrow buffers. This eliminates the overhead of traditional JDBC/ODBC drivers, which are not optimized for bulk columnar access.

Implementation Details§

Given a target database (PostgreSQL or MySQL), the system provides the LLM with:

• The page layout specification (e.g., struct PageHeaderData in PostgreSQL)
• Row/tuple format details (e.g., tuple header, null bitmap)
• Column type decoding logic (e.g., varying-length types, numeric encoding)

The LLM outputs a C function read_table(const char *filepath, Schema *schema) -> ArrowArray that parses each page, iterates tuples, and writes columns sequentially into Arrow arrays. The generated code is compiled and linked into a lightweight reader library.

// Example generated code (simplified)
void read_tpch_lineitem(const char *filepath, ArrowArray *result) {
    PageHeader *page = mmap_file(filepath);
    for (int i = 0; i < page->num_tuples; i++) {
        TupleHeader *tup = get_tuple(page, i);
        // extract each column into Arrow buffers
        append_int32(result->col[0], tup->l_orderkey);
        append_int32(result->col[1], tup->l_partkey);
        // ...
    }
}

Correctness & Performance§

Correctness is validated by comparing generated reader outputs against JDBC/ODBC baselines on TPC-H queries. All queries produce identical results. Performance is evaluated on analytical snapshot scenarios: the reader bypasses the database engine entirely, yielding up to 27x speedup in end-to-end throughput (e.g., reading the lineitem table into DuckDB). The speedup is driven by:

• Elimination of query planning and parsing overhead
• Direct memory-mapped I/O and columnar materialization
• Avoidance of driver-level data conversion

Generalization§

The methodology generalizes to any database system whose file format is documented or open-source. The LLM essentially acts as an agent that reads specifications and writes high-performance parsing code, turning a traditionally manual engineering task into an automated synthesis problem.

Key equation for speedup: $$S = \frac{T_{\text{JDBC/ODBC}}}{T_{\text{Jailbreak}}}$$

where $T$ is end-to-end time to load a table into an in-memory columnar buffer (e.g., Arrow).