Running scripts

use jed::{split_statements, CreateOptions, Database};

fn main() -> jed::Result<()> {
    let mut db = Database::create(CreateOptions { path: Some("app.jed".into()), ..Default::default() })?;

    // execute_script runs a whole migration as ONE implicit transaction: split it into statements,
    // run each in order, and commit all-or-nothing (any error rolls the lot back). It DISCARDS
    // result rows — you get back only an O(1) summary (statements run, rows affected, cost), so a
    // huge import never buffers results.
    let summary = db.execute_script(
        "CREATE TABLE account (id i32 PRIMARY KEY, balance i64);
         INSERT INTO account VALUES (1, 100), (2, 50);
         CREATE INDEX account_balance ON account (balance);",
    )?;
    println!("ran {} statements", summary.statements_run);

    // split_statements is the library-level primitive (no Database needed). When you DO want each
    // statement's rows, loop it yourself and run the spans through the normal path — the host owns
    // the policy (one transaction or autocommit, drain rows or drop them).
    for stmt in split_statements("SELECT id FROM account; SELECT balance FROM account") {
        let _rows = db.query(stmt.text(), &[])?;
    }

    Ok(())
}

package main

import (
	"context"
	"fmt"
	"log"

	jed "github.com/jackc/jed/impl/go"
)

func main() {
	db, err := jed.CreateDatabase(jed.CreateOptions{Path: "app.jed"})
	if err != nil {
		log.Fatal(err)
	}
	defer db.Close()

	ctx := context.Background()

	// ExecuteScript runs a whole migration as ONE implicit transaction: split it into statements,
	// run each in order, and commit all-or-nothing (any error rolls the lot back). It DISCARDS
	// result rows — you get back only an O(1) summary (statements run, rows affected, cost), so a
	// huge import never buffers results.
	summary, err := db.ExecuteScript(
		`CREATE TABLE account (id i32 PRIMARY KEY, balance i64);
		 INSERT INTO account VALUES (1, 100), (2, 50);
		 CREATE INDEX account_balance ON account (balance);`)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("ran %d statements\n", summary.StatementsRun)

	// SplitStatements is the library-level primitive (no Database needed). When you DO want each
	// statement's rows, loop it yourself and run the spans through the normal path — the host owns
	// the policy (one transaction or autocommit, drain rows or drop them).
	for stmt := range jed.SplitStatements("SELECT id FROM account; SELECT balance FROM account") {
		if _, err := db.Query(ctx, stmt.Text); err != nil {
			log.Fatal(err)
		}
	}
}

import { createDatabase, splitStatements } from 'jed-ts';

const db = createDatabase({ path: 'app.jed' });

// executeScript runs a whole migration as ONE implicit transaction: split it into statements, run
// each in order, and commit all-or-nothing (any error rolls the lot back). It DISCARDS result rows —
// you get back only an O(1) summary (statements run, rows affected, cost), so a huge import never
// buffers results.
const summary = db.executeScript(
  `CREATE TABLE account (id i32 PRIMARY KEY, balance i64);
   INSERT INTO account VALUES (1, 100), (2, 50);
   CREATE INDEX account_balance ON account (balance);`
);
console.log(`ran ${summary.statementsRun} statements`);

// splitStatements is the library-level primitive (no Database needed). When you DO want each
// statement's rows, loop it yourself and run the spans through the normal path — the host owns the
// policy (one transaction or autocommit, drain the rows or drop them).
for (const stmt of splitStatements('SELECT id FROM account; SELECT balance FROM account')) {
  db.query(stmt.text);
}

db.close();