Struct OpeningBookDatabase 

pub struct OpeningBookDatabase { /* private fields */ }

Implementations

impl OpeningBookDatabase

pub fn open(config: &OpeningBookConfig) -> SqlResult<Self>

Examples found in repository

examples/depth4_survey.rs (lines 127-130)

fn main() {
    let args = parse_args();

    let started = Instant::now();
    let mut states = enumerate_depth4();
    println!(
        "enumerated {} canonical nonterminal depth-4 states in {:.2}s",
        states.len(),
        started.elapsed().as_secs_f64()
    );
    if args.sample > 0 && args.sample < states.len() {
        use rand::prelude::*;
        let mut rng = StdRng::seed_from_u64(args.seed);
        states.shuffle(&mut rng);
        states.truncate(args.sample);
        states.sort_by_key(|(bb, _)| bb.to_le_bytes());
        println!(
            "sampled {} of {} states (seed={})",
            states.len(),
            10946,
            args.seed
        );
    } else if args.limit > 0 {
        states.truncate(args.limit);
        println!("limited to {} states for this run", states.len());
    }

    let book = OpeningBookDatabase::open(&OpeningBookConfig {
        database_path: args.db.clone(),
        ..Default::default()
    })
    .expect("open book");

    let mut rows: Vec<serde_json::Value> = Vec::with_capacity(states.len());
    let mut solved = 0usize;
    let mut cutoff = 0usize;
    let solve_started = Instant::now();

    for (i, (bb, mult)) in states.iter().enumerate() {
        let t0 = Instant::now();
        let reference = solve_position_with_book(bb, args.budget_s, Some(&book));
        let elapsed = t0.elapsed().as_secs_f64();
        println!(
            "  [{}/{}] {} solved={} elapsed={:.3}s",
            i + 1,
            states.len(),
            State::new(*bb).to_qfen(),
            reference.is_some(),
            elapsed
        );

        match &reference {
            Some(r) => {
                solved += 1;
                rows.push(serde_json::json!({
                    "qfen": State::new(*bb).to_qfen(),
                    "multiplicity": mult,
                    "value": r["value"],
                    "nodes": r["nodes"],
                    "solve_time_s": elapsed,
                    "solver": r["solver"],
                }));
            }
            None => {
                cutoff += 1;
                rows.push(serde_json::json!({
                    "qfen": State::new(*bb).to_qfen(),
                    "multiplicity": mult,
                    "value": null,
                    "nodes": null,
                    "solve_time_s": elapsed,
                    "solver": null,
                }));
            }
        }

        if (i + 1) % 25 == 0 || i + 1 == states.len() {
            println!(
                "progress: {}/{} solved={} cutoff={} elapsed_total={:.1}s",
                i + 1,
                states.len(),
                solved,
                cutoff,
                solve_started.elapsed().as_secs_f64()
            );
            // Flush partial results after every progress line so a killed
            // run still leaves a readable, if incomplete, artifact — the
            // SQLite book itself is already durable per-row regardless.
            let partial = serde_json::json!({
                "budget_s": args.budget_s,
                "total_canonical_depth4_states": states.len(),
                "processed": i + 1,
                "solved": solved,
                "cutoff": cutoff,
                "positions": rows,
            });
            std::fs::write(&args.out, serde_json::to_string_pretty(&partial).unwrap())
                .expect("write partial output");
        }
    }

    println!(
        "done: {} solved, {} cutoff, total solve wall time {:.1}s -> {}",
        solved,
        cutoff,
        solve_started.elapsed().as_secs_f64(),
        args.out
    );
}

pub fn add_position( &self, state: &State, evaluation: f64, visit_count: i64, win_count_p0: i64, win_count_p1: i64, draw_count: i64, best_moves: &[(i32, i32)], depth: i32, is_terminal: TerminalStatus, symmetry_count: i32, ) -> SqlResult<()>

pub fn add_solved_position( &self, state: &State, game_value: i32, optimal_moves: &[(i32, i32)], ) -> SqlResult<bool>

Upsert an exactly-solved position: evaluation is game_value as f64, is_terminal stays Interior (the position itself is not terminal — its game value is exactly known), depth is pieces placed (derived from state.bb), and best_moves records every optimal move (not just a top-5 slice, unlike Self::add_position) as (shape, position) pairs in the given order.

Only canonical representatives are stored. The optimal moves are expressed in state’s own board orientation, but the row is keyed by the canonical key shared by up to eight symmetric orientations; storing a non-representative orientation would let a later lookup on the representative serve moves that are wrong (possibly illegal) for that board. If state is not its own canonical representative (canonical_payload() != bb.to_le_bytes()), nothing is written and Ok(false) is returned; Ok(true) means the row was upserted. Translating moves across orientations via the symmetry transform is a documented follow-up that would lift this restriction.

The position row and its best-move rows are written in one transaction, so a mid-way failure can never leave a solved row with partial best_moves.

Visit/win/draw counters and symmetry_count are not meaningful for a solved reference and are stored as 0.

pub fn get_position(&self, state: &State) -> SqlResult<Option<OpeningBookEntry>>

pub fn query_by_depth( &self, depth: i32, limit: i64, ) -> SqlResult<Vec<OpeningBookEntry>>

pub fn add_edges(&self, edges: &[(&[u8], &[u8])]) -> SqlResult<()>

pub fn get_children(&self, canonical_key: &[u8]) -> SqlResult<Vec<Vec<u8>>>

pub fn get_parents(&self, canonical_key: &[u8]) -> SqlResult<Vec<Vec<u8>>>

pub fn get_edge_count(&self) -> SqlResult<i64>

pub fn total_positions(&self) -> SqlResult<i64>

pub fn max_depth(&self) -> SqlResult<Option<i32>>

pub fn positions_by_depth(&self) -> SqlResult<Vec<(i32, i64)>>

pub fn db_path(&self) -> &str

pub fn file_size(&self) -> u64

Trait Implementations

impl Drop for OpeningBookDatabase

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.