@kromatv/sdk 0.1.40-canary.0

package/rust/kroma-db/src/media.rs

@@ -0,0 +1,296 @@
+//! Catalog reads: counts, movie/item listings and single-item fetches.
+//!
+//! Re-exported flat here so the public `db::<item>` paths resolve unchanged:
+//! [`shows`] carries the show listing, [`show_detail`] one show with its
+//! seasons, and [`splash`] the anonymous sign-in sample.
+
+use rusqlite::OptionalExtension;
+
+use super::*;
+use kroma_domain::{Season, Show, ShowDetail, SplashEntry};
+
+mod person;
+mod show_detail;
+mod shows;
+mod splash;
+
+#[cfg(test)]
+mod test_support;
+
+pub use person::*;
+pub use show_detail::*;
+pub use shows::*;
+pub use splash::*;
+
+/// (libraries, items, shows) counts for `/api/health`.
+pub fn counts(pool: &Pool) -> Result<(usize, usize, usize)> {
+    let conn = pool.get()?;
+    let libs: i64 = conn.query_row("SELECT COUNT(*) FROM libraries", [], |r| r.get(0))?;
+    let items: i64 = conn.query_row("SELECT COUNT(*) FROM items", [], |r| r.get(0))?;
+    let shows: i64 = conn.query_row("SELECT COUNT(*) FROM shows", [], |r| r.get(0))?;
+    Ok((libs as usize, items as usize, shows as usize))
+}
+
+/// Movies (and loose videos) everything that isn't an episode.
+pub fn list_movies(pool: &Pool, library: Option<&str>) -> Result<Vec<MediaItem>> {
+    query_items(
+        pool,
+        &format!("SELECT {ITEM_COLS} FROM items WHERE kind != 'episode'"),
+        library,
+        "ORDER BY title COLLATE NOCASE",
+    )
+}
+
+/// All playable items: movies + episodes.
+pub fn list_items(pool: &Pool, library: Option<&str>) -> Result<Vec<MediaItem>> {
+    query_items(
+        pool,
+        &format!("SELECT {ITEM_COLS} FROM items"),
+        library,
+        "ORDER BY title COLLATE NOCASE",
+    )
+}
+
+pub fn get_item(pool: &Pool, id: &str) -> Result<Option<MediaItem>> {
+    let conn = pool.get()?;
+    let mut stmt = conn.prepare(&format!("SELECT {ITEM_COLS} FROM items WHERE id = ?1"))?;
+    let mut rows = stmt.query_map(params![id], row_to_item)?;
+    match rows.next() {
+        Some(item) => {
+            let mut item = item?;
+            attach_files(&conn, &mut item)?;
+            Ok(Some(item))
+        }
+        None => Ok(None),
+    }
+}
+
+/// Catalogue snapshot for the search index: no per-row file or
+/// representative-video lookups, so a full reindex is two table scans.
+pub fn index_snapshot(pool: &Pool) -> Result<(Vec<MediaItem>, Vec<Show>)> {
+    let conn = pool.get()?;
+    let mut stmt = conn.prepare(&format!("SELECT {ITEM_COLS} FROM items"))?;
+    let items: Vec<MediaItem> = stmt
+        .query_map([], row_to_item)?
+        .collect::<rusqlite::Result<Vec<_>>>()?;
+    let mut stmt = conn.prepare("SELECT id,title,year,library,added_at,metadata FROM shows")?;
+    let shows: Vec<Show> = stmt
+        .query_map([], row_to_show_bare)?
+        .collect::<rusqlite::Result<Vec<_>>>()?;
+    Ok((items, shows))
+}
+
+/// Order is unspecified the caller re-orders by relevance.
+pub fn get_items_by_ids(pool: &Pool, ids: &[String]) -> Result<Vec<MediaItem>> {
+    if ids.is_empty() {
+        return Ok(Vec::new());
+    }
+    let conn = pool.get()?;
+    let ids: Vec<&str> = ids.iter().map(String::as_str).collect();
+    Ok(items_by_ids_ordered(&conn, &ids)?)
+}
+
+fn query_items(
+    pool: &Pool,
+    base: &str,
+    library: Option<&str>,
+    tail: &str,
+) -> Result<Vec<MediaItem>> {
+    let conn = pool.get()?;
+    let mut items: Vec<MediaItem> = match library {
+        Some(lib) => {
+            let sql = format!(
+                "{base} {} {tail}",
+                if base.contains("WHERE") {
+                    "AND library = ?1"
+                } else {
+                    "WHERE library = ?1"
+                }
+            );
+            let mut stmt = conn.prepare(&sql)?;
+            let rows = stmt.query_map(params![lib], row_to_item)?;
+            rows.collect::<rusqlite::Result<Vec<_>>>()?
+        }
+        None => {
+            let sql = format!("{base} {tail}");
+            let mut stmt = conn.prepare(&sql)?;
+            let rows = stmt.query_map([], row_to_item)?;
+            rows.collect::<rusqlite::Result<Vec<_>>>()?
+        }
+    };
+    attach_files_batch(&conn, &mut items)?;
+    Ok(items)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::media::test_support::*;
+    use kroma_domain::Kind;
+
+    #[test]
+    fn counts_reflects_seeded_rows() {
+        let p = pool();
+        {
+            let conn = p.get().unwrap();
+            conn.execute(
+                "INSERT INTO libraries (id,name,kind,path,added_at) VALUES ('lib','L','movies','/x','t')",
+                [],
+            )
+            .unwrap();
+            seed_movie(&conn, "m1", "Dune", "lib");
+            conn.execute(
+                "INSERT INTO shows (id,library,title,added_at) VALUES ('s1','lib','Show','t')",
+                [],
+            )
+            .unwrap();
+        }
+        assert_eq!(counts(&p).unwrap(), (1, 1, 1));
+    }
+
+    #[test]
+    fn list_movies_and_items_ordering_and_episode_split() {
+        let p = pool();
+        {
+            let conn = p.get().unwrap();
+            conn.execute(
+                "INSERT INTO libraries (id,name,kind,path,added_at) VALUES ('lib','L','movies','/x','t')",
+                [],
+            )
+            .unwrap();
+            conn.execute(
+                "INSERT INTO libraries (id,name,kind,path,added_at) VALUES ('lib2','L2','movies','/y','t')",
+                [],
+            )
+            .unwrap();
+            seed_movie(&conn, "m1", "Dune", "lib");
+            seed_movie(&conn, "m2", "Arrival", "lib");
+            seed_movie(&conn, "mo", "Other", "lib2");
+            conn.execute(
+                "INSERT INTO shows (id,library,title,added_at) VALUES ('s1','lib','Show','t')",
+                [],
+            )
+            .unwrap();
+            conn.execute(
+                "INSERT INTO items (id,kind,title,container,library,show_id,season,episode,added_at) \
+                 VALUES ('e1','episode','Ep','mkv','lib','s1',1,1,'t')",
+                [],
+            )
+            .unwrap();
+        }
+        let movies = list_movies(&p, None).unwrap();
+        assert_eq!(
+            movies.iter().map(|i| i.id.as_str()).collect::<Vec<_>>(),
+            ["m2", "m1", "mo"]
+        );
+        assert!(movies.iter().all(|i| i.kind != Kind::Episode));
+
+        let lib_movies = list_movies(&p, Some("lib")).unwrap();
+        assert_eq!(
+            lib_movies.iter().map(|i| i.id.as_str()).collect::<Vec<_>>(),
+            ["m2", "m1"]
+        );
+
+        let items = list_items(&p, None).unwrap();
+        assert!(items.iter().any(|i| i.id == "e1"));
+        assert_eq!(items.len(), 4);
+    }
+
+    #[test]
+    fn get_item_hydrates_representative_file() {
+        let p = pool();
+        {
+            let conn = p.get().unwrap();
+            conn.execute(
+                "INSERT INTO libraries (id,name,kind,path,added_at) VALUES ('lib','L','movies','/x','t')",
+                [],
+            )
+            .unwrap();
+            seed_movie(&conn, "m1", "Dune", "lib");
+            seed_probed_file(&conn, "f1", "m1", "/media/dune.mkv", 3840);
+        }
+        let item = get_item(&p, "m1").unwrap().unwrap();
+        assert_eq!(item.default_file_id.as_deref(), Some("f1"));
+        assert_eq!(item.abs_path.as_deref(), Some("/media/dune.mkv"));
+        assert_eq!(item.container, "mkv");
+        assert_eq!(item.duration_ms, Some(7_200_000));
+        let video = item.video.expect("probed file yields a video stream");
+        assert_eq!(video.codec, "hevc");
+        assert_eq!(video.width, Some(3840));
+        assert_eq!(item.files.len(), 1);
+
+        assert!(get_item(&p, "missing").unwrap().is_none());
+    }
+
+    #[test]
+    fn by_ids_and_index_snapshot() {
+        let p = pool();
+        {
+            let conn = p.get().unwrap();
+            conn.execute(
+                "INSERT INTO libraries (id,name,kind,path,added_at) VALUES ('lib','L','movies','/x','t')",
+                [],
+            )
+            .unwrap();
+            seed_movie(&conn, "m1", "Dune", "lib");
+            seed_movie(&conn, "m2", "Arrival", "lib");
+            conn.execute(
+                "INSERT INTO shows (id,library,title,added_at) VALUES ('s1','lib','Show','t')",
+                [],
+            )
+            .unwrap();
+        }
+        assert!(get_items_by_ids(&p, &[]).unwrap().is_empty());
+        assert!(get_shows_by_ids(&p, &[]).unwrap().is_empty());
+
+        let items = get_items_by_ids(&p, &["m2".into(), "m1".into(), "ghost".into()]).unwrap();
+        let mut ids: Vec<&str> = items.iter().map(|i| i.id.as_str()).collect();
+        ids.sort();
+        assert_eq!(ids, ["m1", "m2"]);
+
+        let shows = get_shows_by_ids(&p, &["s1".into()]).unwrap();
+        assert_eq!(shows.len(), 1);
+        assert_eq!(shows[0].id, "s1");
+
+        let (items, shows) = index_snapshot(&p).unwrap();
+        assert_eq!(items.len(), 2);
+        assert_eq!(shows.len(), 1);
+    }
+
+    const SQLITE_BIND_LIMIT: usize = 32_766;
+
+    fn padded_past_the_bind_limit(real: &str) -> Vec<String> {
+        let mut ids: Vec<String> = (0..=SQLITE_BIND_LIMIT)
+            .map(|n| format!("absent{n}"))
+            .collect();
+        ids.push(real.to_string());
+        ids
+    }
+
+    #[test]
+    fn a_by_ids_read_longer_than_sqlite_can_bind_still_answers() {
+        let p = pool();
+        {
+            let conn = p.get().unwrap();
+            conn.execute(
+                "INSERT INTO libraries (id,name,kind,path,added_at) VALUES ('lib','L','movies','/x','t')",
+                [],
+            )
+            .unwrap();
+            seed_movie(&conn, "m1", "Dune", "lib");
+            conn.execute(
+                "INSERT INTO shows (id,library,title,added_at) VALUES ('s1','lib','Show','t')",
+                [],
+            )
+            .unwrap();
+        }
+
+        let items = get_items_by_ids(&p, &padded_past_the_bind_limit("m1")).unwrap();
+        let shows = get_shows_by_ids(&p, &padded_past_the_bind_limit("s1")).unwrap();
+
+        assert_eq!(items.len(), 1);
+        assert_eq!(items[0].id, "m1");
+        assert_eq!(shows.len(), 1);
+        assert_eq!(shows[0].id, "s1");
+    }
+}

package/rust/kroma-db/src/metadata_core.rs

@@ -0,0 +1,348 @@
+//! Language-invariant resolved metadata (`metadata_core`): one row per catalog
+//! subject (a movie/video item OR a show). This is the identity / art / people
+//! layer that never changes with the UI language the per-language text lives in
+//! [`super::translations`]. Promoting `tmdb_id` to a real column here also makes
+//! availability matching a plain indexed seek instead of a `json_extract` scan.
+//!
+//! Not yet wired into the read/write paths (built additively ahead of the
+//! cutover); remove the `dead_code` allowance once enrichment + serving move over.
+#![allow(dead_code)]
+
+use std::collections::HashMap;
+
+use super::*;
+
+use kroma_domain::{CastMember, CrewMember};
+
+/// Subject-kind discriminants for `metadata_core` / `translations` rows.
+pub const ITEM: &str = "item";
+pub const SHOW: &str = "show";
+
+/// The invariant half of a title's metadata. `cast` / `crew` are the people
+/// (names + photos); the localized character names live per-language in
+/// [`super::translations::TransData::characters`], aligned to `cast` by index.
+#[derive(Debug, Clone, Default)]
+pub struct MetaCore {
+    pub tmdb_id: Option<u64>,
+    pub imdb_id: Option<String>,
+    pub tvdb_id: Option<u64>,
+    pub release_date: Option<String>,
+    pub rating: Option<f32>,
+    pub certification: Option<String>,
+    pub poster_url: Option<String>,
+    pub backdrop_url: Option<String>,
+    pub logo_url: Option<String>,
+    pub cast: Vec<CastMember>,
+    pub crew: Vec<CrewMember>,
+    pub tmdb_genre_ids: Vec<u32>,
+}
+
+// Column list for core SELECTs keeps [`row_to_core`] index-stable.
+const CORE_COLS: &str = "tmdb_id,imdb_id,tvdb_id,release_date,rating,certification,poster_url,\
+     backdrop_url,logo_url,cast_json,crew_json,tmdb_genre_ids";
+
+/// Upsert one subject's invariant core. Character names are stripped from `cast`
+/// before storing they are language-variant and belong in `translations`.
+pub fn set_core(pool: &Pool, kind: &str, id: &str, core: &MetaCore) -> Result<()> {
+    let conn = pool.get()?;
+    write_core(&conn, kind, id, core)
+}
+
+/// Connection-level upsert (shares one tx/connection with a caller doing a batch).
+pub(crate) fn write_core(conn: &Connection, kind: &str, id: &str, core: &MetaCore) -> Result<()> {
+    // Store people without their (localized) character it lives in translations.
+    let cast: Vec<CastMember> = core
+        .cast
+        .iter()
+        .cloned()
+        .map(|c| CastMember {
+            character: None,
+            ..c
+        })
+        .collect();
+    let cast_json = serde_json::to_string(&cast).unwrap_or_else(|_| "[]".into());
+    let crew_json = serde_json::to_string(&core.crew).unwrap_or_else(|_| "[]".into());
+    let genre_ids_json =
+        serde_json::to_string(&core.tmdb_genre_ids).unwrap_or_else(|_| "[]".into());
+    conn.execute(
+        "INSERT INTO metadata_core \
+            (subject_kind,subject_id,tmdb_id,imdb_id,tvdb_id,release_date,rating,certification,\
+             poster_url,backdrop_url,logo_url,cast_json,crew_json,tmdb_genre_ids,updated_at) \
+         VALUES (?1,?2,?3,?4,?5,?6,?7,?8,?9,?10,?11,?12,?13,?14,?15) \
+         ON CONFLICT(subject_kind,subject_id) DO UPDATE SET \
+             tmdb_id=excluded.tmdb_id, imdb_id=excluded.imdb_id, tvdb_id=excluded.tvdb_id, \
+             release_date=excluded.release_date, rating=excluded.rating, \
+             certification=excluded.certification, \
+             poster_url=excluded.poster_url, backdrop_url=excluded.backdrop_url, \
+             logo_url=excluded.logo_url, cast_json=excluded.cast_json, \
+             crew_json=excluded.crew_json, tmdb_genre_ids=excluded.tmdb_genre_ids, \
+             updated_at=excluded.updated_at",
+        params![
+            kind,
+            id,
+            core.tmdb_id.map(|v| v as i64),
+            core.imdb_id,
+            core.tvdb_id.map(|v| v as i64),
+            core.release_date,
+            core.rating,
+            core.certification,
+            core.poster_url,
+            core.backdrop_url,
+            core.logo_url,
+            cast_json,
+            crew_json,
+            genre_ids_json,
+            kroma_primitives::now_ms(),
+        ],
+    )?;
+    Ok(())
+}
+
+/// One subject's invariant core, or `None` if not yet enriched.
+pub fn get_core(pool: &Pool, kind: &str, id: &str) -> Result<Option<MetaCore>> {
+    let conn = pool.get()?;
+    let mut stmt = conn.prepare(&format!(
+        "SELECT {CORE_COLS} FROM metadata_core WHERE subject_kind=?1 AND subject_id=?2"
+    ))?;
+    let mut rows = stmt.query_map(params![kind, id], row_to_core)?;
+    match rows.next() {
+        Some(r) => Ok(Some(r?)),
+        None => Ok(None),
+    }
+}
+
+/// Invariant cores for a batch of ids (one query per id-chunk), keyed by id.
+pub fn get_cores(conn: &Connection, kind: &str, ids: &[&str]) -> Result<HashMap<String, MetaCore>> {
+    let rows = super::query_by_subject_ids(
+        conn,
+        kind,
+        ids,
+        &[],
+        |ph| {
+            format!(
+                "SELECT subject_id,{CORE_COLS} FROM metadata_core \
+                 WHERE subject_kind=? AND subject_id IN ({ph})"
+            )
+        },
+        // subject_id is col 0; core cols shift by one.
+        |r| Ok((r.get::<_, String>(0)?, row_to_core_offset(r, 1)?)),
+    )?;
+    Ok(rows.into_iter().collect())
+}
+
+fn row_to_core(r: &Row) -> rusqlite::Result<MetaCore> {
+    row_to_core_offset(r, 0)
+}
+
+// Row mapper starting at column `base` (so callers can prepend `subject_id`).
+fn row_to_core_offset(r: &Row, base: usize) -> rusqlite::Result<MetaCore> {
+    let cast_json: String = r.get(base + 9)?;
+    let crew_json: String = r.get(base + 10)?;
+    let genre_ids_json: String = r.get(base + 11)?;
+    Ok(MetaCore {
+        tmdb_id: r.get::<_, Option<i64>>(base)?.map(|v| v as u64),
+        imdb_id: r.get(base + 1)?,
+        tvdb_id: r.get::<_, Option<i64>>(base + 2)?.map(|v| v as u64),
+        release_date: r.get(base + 3)?,
+        rating: r.get(base + 4)?,
+        certification: r.get(base + 5)?,
+        poster_url: r.get(base + 6)?,
+        backdrop_url: r.get(base + 7)?,
+        logo_url: r.get(base + 8)?,
+        cast: serde_json::from_str(&cast_json).unwrap_or_default(),
+        crew: serde_json::from_str(&crew_json).unwrap_or_default(),
+        tmdb_genre_ids: serde_json::from_str(&genre_ids_json).unwrap_or_default(),
+    })
+}
+
+/// Delete one subject's core (paired with a translations wipe on re-language /
+/// reprocess). Errors are propagated; a missing row is a no-op.
+pub fn delete_core(conn: &Connection, kind: &str, id: &str) -> Result<()> {
+    conn.execute(
+        "DELETE FROM metadata_core WHERE subject_kind=?1 AND subject_id=?2",
+        params![kind, id],
+    )?;
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::testing::TempPool;
+    use kroma_domain::{CastMember, CrewMember};
+
+    fn pool() -> TempPool {
+        crate::testing::temp_pool("core")
+    }
+
+    fn sample_core() -> MetaCore {
+        MetaCore {
+            tmdb_id: Some(603),
+            imdb_id: Some("tt0133093".into()),
+            tvdb_id: Some(42),
+            release_date: Some("1999-03-31".into()),
+            rating: Some(8.7),
+            certification: Some("R".into()),
+            poster_url: Some("/api/images/p.webp".into()),
+            backdrop_url: Some("/api/images/b.webp".into()),
+            logo_url: None,
+            cast: vec![CastMember {
+                name: "Keanu".into(),
+                tmdb_id: None,
+                character: Some("Neo".into()),
+                profile_url: Some("/api/images/k.webp".into()),
+            }],
+            crew: vec![CrewMember {
+                name: "Wachowski".into(),
+                tmdb_id: None,
+                job: "Director".into(),
+                profile_url: None,
+            }],
+            tmdb_genre_ids: vec![878, 28],
+        }
+    }
+
+    #[test]
+    fn set_get_upsert_and_strip_character() {
+        let p = pool();
+        set_core(&p, ITEM, "m1", &sample_core()).unwrap();
+        let got = get_core(&p, ITEM, "m1").unwrap().unwrap();
+        assert_eq!(got.tmdb_id, Some(603));
+        assert_eq!(got.imdb_id.as_deref(), Some("tt0133093"));
+        assert_eq!(got.tvdb_id, Some(42));
+        assert_eq!(got.rating, Some(8.7));
+        assert_eq!(got.poster_url.as_deref(), Some("/api/images/p.webp"));
+        // People are kept, but their (localized) character is stripped from core.
+        assert_eq!(got.cast.len(), 1);
+        assert_eq!(got.cast[0].name, "Keanu");
+        assert!(got.cast[0].character.is_none());
+        assert_eq!(
+            got.cast[0].profile_url.as_deref(),
+            Some("/api/images/k.webp")
+        );
+        assert_eq!(got.crew.len(), 1);
+        assert_eq!(got.crew[0].job, "Director");
+
+        // Upsert overwrites in place.
+        let mut updated = sample_core();
+        updated.tmdb_id = Some(999);
+        updated.rating = None;
+        set_core(&p, ITEM, "m1", &updated).unwrap();
+        let got = get_core(&p, ITEM, "m1").unwrap().unwrap();
+        assert_eq!(got.tmdb_id, Some(999));
+        assert!(got.rating.is_none());
+
+        assert!(get_core(&p, ITEM, "missing").unwrap().is_none());
+    }
+
+    #[test]
+    fn the_age_rating_survives_a_round_trip() {
+        let p = pool();
+
+        set_core(&p, ITEM, "m1", &sample_core()).unwrap();
+
+        assert_eq!(
+            get_core(&p, ITEM, "m1").unwrap().unwrap().certification,
+            Some("R".to_string())
+        );
+    }
+
+    #[test]
+    fn a_row_stored_before_the_age_rating_reads_as_having_none() {
+        let p = pool();
+        p.get()
+            .unwrap()
+            .execute(
+                "INSERT INTO metadata_core (subject_kind,subject_id,tmdb_id,updated_at) \
+                 VALUES ('item','old',603,0)",
+                [],
+            )
+            .unwrap();
+
+        assert!(get_core(&p, ITEM, "old")
+            .unwrap()
+            .unwrap()
+            .certification
+            .is_none());
+    }
+
+    #[test]
+    fn the_genre_ids_survive_a_round_trip() {
+        let p = pool();
+
+        set_core(&p, ITEM, "m1", &sample_core()).unwrap();
+
+        assert_eq!(
+            get_core(&p, ITEM, "m1").unwrap().unwrap().tmdb_genre_ids,
+            vec![878, 28]
+        );
+    }
+
+    #[test]
+    fn a_row_stored_before_the_genre_ids_reads_as_having_none() {
+        let p = pool();
+        p.get()
+            .unwrap()
+            .execute(
+                "INSERT INTO metadata_core (subject_kind,subject_id,tmdb_id,updated_at) \
+                 VALUES ('item','old',603,0)",
+                [],
+            )
+            .unwrap();
+
+        let got = get_core(&p, ITEM, "old").unwrap().unwrap();
+
+        assert_eq!(got.tmdb_id, Some(603));
+        assert!(got.tmdb_genre_ids.is_empty());
+    }
+
+    #[test]
+    fn kinds_are_independent() {
+        let p = pool();
+        let mut show = sample_core();
+        show.tmdb_id = Some(1396);
+        set_core(&p, ITEM, "x", &sample_core()).unwrap();
+        set_core(&p, SHOW, "x", &show).unwrap();
+        // Same id, different kind: no collision.
+        assert_eq!(get_core(&p, ITEM, "x").unwrap().unwrap().tmdb_id, Some(603));
+        assert_eq!(
+            get_core(&p, SHOW, "x").unwrap().unwrap().tmdb_id,
+            Some(1396)
+        );
+    }
+
+    #[test]
+    fn get_cores_batch_and_delete() {
+        let p = pool();
+        set_core(&p, ITEM, "m1", &sample_core()).unwrap();
+        let mut second = sample_core();
+        second.tmdb_id = Some(500);
+        set_core(&p, ITEM, "m2", &second).unwrap();
+
+        let conn = p.get().unwrap();
+        let cores = get_cores(&conn, ITEM, &["m1", "m2", "ghost"]).unwrap();
+        assert_eq!(cores.len(), 2);
+        assert_eq!(cores["m1"].tmdb_id, Some(603));
+        assert_eq!(cores["m2"].tmdb_id, Some(500));
+
+        delete_core(&conn, ITEM, "m1").unwrap();
+        assert!(get_core(&p, ITEM, "m1").unwrap().is_none());
+        assert!(get_core(&p, ITEM, "m2").unwrap().is_some());
+        // Deleting a missing row is a no-op (no error).
+        delete_core(&conn, ITEM, "m1").unwrap();
+    }
+
+    #[test]
+    fn a_core_table_that_is_gone_errors_on_every_operation() {
+        let p = pool();
+        p.get()
+            .unwrap()
+            .execute_batch("DROP TABLE metadata_core")
+            .unwrap();
+
+        assert!(set_core(&p, ITEM, "m1", &sample_core()).is_err());
+        let conn = p.get().unwrap();
+        assert!(get_cores(&conn, ITEM, &["m1"]).is_err());
+        assert!(delete_core(&conn, ITEM, "m1").is_err());
+    }
+}