library: New query logic

data/ui/home_page.blp

@@ -164,6 +164,26 @@ template $MusicusHomePage: Adw.NavigationPage {
                   child-activated => $tile_selected() swapped;
                 }
 
+                Gtk.Label {
+                  styles [
+                    "heading"
+                  ]
+
+                  visible: bind instruments_flow_box.visible;
+                  halign: start;
+                  label: _("Instruments");
+                }
+
+                Gtk.FlowBox instruments_flow_box {
+                  margin-top: 12;
+                  margin-bottom: 24;
+                  column-spacing: 12;
+                  row-spacing: 12;
+                  homogeneous: true;
+                  selection-mode: none;
+                  child-activated => $tile_selected() swapped;
+                }
+
                 Gtk.Label {
                   styles [
                     "heading"

src/home_page.rs

@@ -11,7 +11,10 @@ use crate::{
     album_tile::AlbumTile,
     config,
     db::models::*,
-    editor::{ensemble::EnsembleEditor, person::PersonEditor, work::WorkEditor},
+    editor::{
+        ensemble::EnsembleEditor, instrument::InstrumentEditor, person::PersonEditor,
+        work::WorkEditor,
+    },
     library::{Library, LibraryQuery},
     player::Player,
     program::Program,
@@ -42,6 +45,7 @@ mod imp {
         pub composers: RefCell<Vec<Person>>,
         pub performers: RefCell<Vec<Person>>,
         pub ensembles: RefCell<Vec<Ensemble>>,
+        pub instruments: RefCell<Vec<Instrument>>,
         pub works: RefCell<Vec<Work>>,
         pub recordings: RefCell<Vec<Recording>>,
         pub albums: RefCell<Vec<Album>>,
@@ -65,6 +69,8 @@ mod imp {
         #[template_child]
         pub ensembles_flow_box: TemplateChild<gtk::FlowBox>,
         #[template_child]
+        pub instruments_flow_box: TemplateChild<gtk::FlowBox>,
+        #[template_child]
         pub works_flow_box: TemplateChild<gtk::FlowBox>,
         #[template_child]
         pub recordings_flow_box: TemplateChild<gtk::FlowBox>,
@@ -176,6 +182,11 @@ impl HomePage {
                         Some(ensemble),
                     ));
                 }
+                Tag::Instrument(instrument) => self.navigation().push(&InstrumentEditor::new(
+                    &self.navigation(),
+                    &self.library(),
+                    Some(instrument),
+                )),
                 Tag::Work(work) => self.navigation().push(&WorkEditor::new(
                     &self.navigation(),
                     &self.library(),
@@ -203,11 +214,12 @@ impl HomePage {
                 self.player().set_program(program);
             }
         } else {
-            let (composer, performer, ensemble, work, recording, album) = {
+            let (composer, performer, ensemble, instrument, work, recording, album) = {
                 (
                     imp.composers.borrow().first().cloned(),
                     imp.performers.borrow().first().cloned(),
                     imp.ensembles.borrow().first().cloned(),
+                    imp.instruments.borrow().first().cloned(),
                     imp.works.borrow().first().cloned(),
                     imp.recordings.borrow().first().cloned(),
                     imp.albums.borrow().first().cloned(),
@@ -220,6 +232,8 @@ impl HomePage {
                 search_entry.add_tag(Tag::Performer(person));
             } else if let Some(ensemble) = ensemble {
                 search_entry.add_tag(Tag::Ensemble(ensemble));
+            } else if let Some(instrument) = instrument {
+                search_entry.add_tag(Tag::Instrument(instrument));
             } else if let Some(work) = work {
                 search_entry.add_tag(Tag::Work(work));
             } else if let Some(recording) = recording {
@@ -266,6 +280,7 @@ impl HomePage {
             &imp.composers_flow_box,
             &imp.performers_flow_box,
             &imp.ensembles_flow_box,
+            &imp.instruments_flow_box,
             &imp.works_flow_box,
             &imp.recordings_flow_box,
             &imp.albums_flow_box,
@@ -287,6 +302,10 @@ impl HomePage {
                     imp.title_label.set_text(&ensemble.name.get());
                     imp.subtitle_label.set_visible(false);
                 }
+                Tag::Instrument(instrument) => {
+                    imp.title_label.set_text(&instrument.name.get());
+                    imp.subtitle_label.set_visible(false);
+                }
                 Tag::Work(work) => {
                     imp.title_label.set_text(&work.name.get());
                     if let Some(composers) = work.composers_string() {
@@ -314,6 +333,8 @@ impl HomePage {
                 .set_visible(!results.performers.is_empty());
             imp.ensembles_flow_box
                 .set_visible(!results.ensembles.is_empty());
+            imp.instruments_flow_box
+                .set_visible(!results.instruments.is_empty());
             imp.works_flow_box.set_visible(!results.works.is_empty());
             imp.recordings_flow_box
                 .set_visible(!results.recordings.is_empty());
@@ -334,6 +355,11 @@ impl HomePage {
                     .append(&TagTile::new(Tag::Ensemble(ensemble.clone())));
             }
 
+            for instrument in &results.instruments {
+                imp.instruments_flow_box
+                    .append(&TagTile::new(Tag::Instrument(instrument.clone())));
+            }
+
             for work in &results.works {
                 imp.works_flow_box
                     .append(&TagTile::new(Tag::Work(work.clone())));
@@ -354,6 +380,7 @@ impl HomePage {
             imp.composers.replace(results.composers);
             imp.performers.replace(results.performers);
             imp.ensembles.replace(results.ensembles);
+            imp.instruments.replace(results.instruments);
             imp.works.replace(results.works);
             imp.recordings.replace(results.recordings);
             imp.albums.replace(results.albums);

src/library.rs

@@ -78,320 +78,359 @@ impl Library {
         let connection = &mut *binding.as_mut().unwrap();
 
         Ok(match query {
-            LibraryQuery {
+            LibraryQuery { work: None, .. } => {
-                composer: None,
+                let composers = if query.composer.is_none() {
-                performer: None,
+                    let mut statement = persons::table
-                ensemble: None,
+                        .inner_join(
-                work: None,
+                            work_persons::table.inner_join(
-                ..
+                                works::table
-            } => {
+                                    .inner_join(
-                let composers: Vec<Person> = persons::table
+                                        recordings::table
-                    .filter(
+                                            .left_join(recording_ensembles::table.inner_join(
-                        exists(
+                                                ensembles::table.left_join(ensemble_persons::table),
-                            work_persons::table
-                                .filter(work_persons::person_id.eq(persons::person_id)),
-                        )
-                        .and(persons::name.like(&search)),
-                    )
-                    .limit(9)
-                    .load(connection)?;
-
-                let performers: Vec<Person> = persons::table
-                    .filter(
-                        exists(
-                            recording_persons::table
-                                .filter(recording_persons::person_id.eq(persons::person_id)),
-                        )
-                        .and(persons::name.like(&search)),
-                    )
-                    .limit(9)
-                    .load(connection)?;
-
-                // TODO: Search ensemble persons as well.
-                let ensembles: Vec<Ensemble> = ensembles::table
-                    .filter(ensembles::name.like(&search))
-                    .limit(9)
-                    .load::<tables::Ensemble>(connection)?
-                    .into_iter()
-                    .map(|e| Ensemble::from_table(e, connection))
-                    .collect::<Result<Vec<Ensemble>>>()?;
-
-                let works: Vec<Work> = works::table
-                    .left_join(work_persons::table.inner_join(persons::table))
-                    .filter(
-                        works::parent_work_id
-                            .is_null()
-                            .and(works::name.like(&search).or(persons::name.like(&search))),
-                    )
-                    .limit(9)
-                    .select(works::all_columns)
-                    .distinct()
-                    .load::<tables::Work>(connection)?
-                    .into_iter()
-                    .map(|w| Work::from_table(w, connection))
-                    .collect::<Result<Vec<Work>>>()?;
-
-                let albums = albums::table
-                    .filter(albums::name.like(&search))
-                    .limit(9)
-                    .load::<tables::Album>(connection)?
-                    .into_iter()
-                    .map(|a| Album::from_table(a, connection))
-                    .collect::<Result<Vec<Album>>>()?;
-
-                LibraryResults {
-                    composers,
-                    performers,
-                    ensembles,
-                    works,
-                    albums,
-                    ..Default::default()
-                }
-            }
-            LibraryQuery {
-                composer: Some(composer),
-                performer: None,
-                ensemble: None,
-                work: None,
-                ..
-            } => {
-                let performers: Vec<Person> = persons::table
-                    .inner_join(recording_persons::table.inner_join(
-                        recordings::table.inner_join(works::table.inner_join(work_persons::table)),
                                             ))
-                    .filter(
+                                            .left_join(recording_persons::table),
-                        work_persons::person_id
-                            .eq(&composer.person_id)
-                            .and(persons::name.like(&search)),
                                     )
+                                    .left_join(work_instruments::table),
+                            ),
+                        )
+                        .filter(persons::name.like(&search))
+                        .into_boxed();
+
+                    if let Some(person) = &query.performer {
+                        statement = statement.filter(
+                            recording_persons::person_id
+                                .eq(&person.person_id)
+                                .or(ensemble_persons::person_id.eq(&person.person_id)),
+                        );
+                    }
+
+                    if let Some(ensemble) = &query.ensemble {
+                        statement = statement
+                            .filter(recording_ensembles::ensemble_id.eq(&ensemble.ensemble_id));
+                    }
+
+                    if let Some(instrument) = &query.instrument {
+                        statement = statement.filter(
+                            work_instruments::instrument_id
+                                .eq(&instrument.instrument_id)
+                                .or(recording_persons::instrument_id.eq(&instrument.instrument_id)),
+                        );
+                    }
+
+                    statement
                         .limit(9)
                         .select(persons::all_columns)
                         .distinct()
-                    .load(connection)?;
+                        .load::<Person>(connection)?
+                } else {
+                    Vec::new()
+                };
 
-                let ensembles: Vec<Ensemble> = ensembles::table
+                let performers = if query.performer.is_none() {
-                    .inner_join(recording_ensembles::table.inner_join(
+                    let mut statement = persons::table
-                        recordings::table.inner_join(works::table.inner_join(work_persons::table)),
+                        .inner_join(
-                    ))
+                            recording_persons::table.inner_join(
-                    .filter(
+                                recordings::table
-                        work_persons::person_id
+                                    .inner_join(
-                            .eq(&composer.person_id)
+                                        works::table
-                            .and(ensembles::name.like(&search)),
+                                            .left_join(work_persons::table)
+                                            .left_join(work_instruments::table),
                                     )
+                                    .left_join(recording_ensembles::table),
+                            ),
+                        )
+                        .filter(persons::name.like(&search))
+                        .into_boxed();
+
+                    if let Some(person) = &query.composer {
+                        statement = statement.filter(work_persons::person_id.eq(&person.person_id));
+                    }
+
+                    if let Some(ensemble) = &query.ensemble {
+                        statement = statement
+                            .filter(recording_ensembles::ensemble_id.eq(&ensemble.ensemble_id));
+                    }
+
+                    if let Some(instrument) = &query.instrument {
+                        statement = statement.filter(
+                            work_instruments::instrument_id
+                                .eq(&instrument.instrument_id)
+                                .or(recording_persons::instrument_id.eq(&instrument.instrument_id)),
+                        );
+                    }
+
+                    statement
+                        .limit(9)
+                        .select(persons::all_columns)
+                        .distinct()
+                        .load::<Person>(connection)?
+                } else {
+                    Vec::new()
+                };
+
+                let ensembles = if query.ensemble.is_none() {
+                    let mut statement = ensembles::table
+                        .inner_join(
+                            recording_ensembles::table.inner_join(
+                                recordings::table
+                                    .inner_join(
+                                        works::table
+                                            .left_join(work_persons::table)
+                                            .left_join(work_instruments::table),
+                                    )
+                                    .left_join(recording_persons::table),
+                            ),
+                        )
+                        .left_join(ensemble_persons::table.inner_join(persons::table))
+                        .filter(
+                            ensembles::name
+                                .like(&search)
+                                .or(persons::name.like(&search)),
+                        )
+                        .into_boxed();
+
+                    if let Some(person) = &query.composer {
+                        statement = statement.filter(work_persons::person_id.eq(&person.person_id));
+                    }
+
+                    if let Some(person) = &query.performer {
+                        statement = statement.filter(
+                            recording_persons::person_id
+                                .eq(&person.person_id)
+                                .or(ensemble_persons::person_id.eq(&person.person_id)),
+                        );
+                    }
+
+                    if let Some(instrument) = &query.instrument {
+                        statement = statement.filter(
+                            work_instruments::instrument_id
+                                .eq(&instrument.instrument_id)
+                                .or(ensemble_persons::instrument_id.eq(&instrument.instrument_id)),
+                        );
+                    }
+
+                    statement
                         .limit(9)
                         .select(ensembles::all_columns)
                         .distinct()
                         .load::<tables::Ensemble>(connection)?
                         .into_iter()
                         .map(|e| Ensemble::from_table(e, connection))
-                    .collect::<Result<Vec<Ensemble>>>()?;
+                        .collect::<Result<Vec<Ensemble>>>()?
+                } else {
+                    Vec::new()
+                };
 
-                let works: Vec<Work> = works::table
+                let instruments = if query.instrument.is_none() {
-                    .inner_join(work_persons::table)
+                    let mut statement = instruments::table
-                    .filter(
+                        .left_join(
-                        work_persons::person_id
+                            work_instruments::table
-                            .eq(&composer.person_id)
+                                .inner_join(works::table.left_join(work_persons::table)),
-                            .and(works::name.like(&search)),
                         )
+                        .left_join(recording_persons::table)
+                        .left_join(ensemble_persons::table)
+                        .filter(instruments::name.like(&search))
+                        .into_boxed();
+
+                    if let Some(person) = &query.composer {
+                        statement = statement.filter(work_persons::person_id.eq(&person.person_id));
+                    }
+
+                    if let Some(person) = &query.performer {
+                        statement = statement.filter(
+                            recording_persons::person_id
+                                .eq(&person.person_id)
+                                .or(ensemble_persons::person_id.eq(&person.person_id)),
+                        );
+                    }
+
+                    if let Some(ensemble) = &query.ensemble {
+                        statement = statement
+                            .filter(ensemble_persons::ensemble_id.eq(&ensemble.ensemble_id));
+                    }
+
+                    statement
+                        .limit(9)
+                        .select(instruments::all_columns)
+                        .distinct()
+                        .load::<Instrument>(connection)?
+                } else {
+                    Vec::new()
+                };
+
+                let works = if query.work.is_none() {
+                    let mut statement = works::table
+                        .left_join(work_persons::table)
+                        .inner_join(
+                            recordings::table
+                                .left_join(recording_persons::table)
+                                .left_join(recording_ensembles::table.left_join(
+                                    ensembles::table.inner_join(ensemble_persons::table),
+                                )),
+                        )
+                        .left_join(work_instruments::table)
+                        .filter(works::name.like(&search))
+                        .into_boxed();
+
+                    if let Some(person) = &query.composer {
+                        statement = statement.filter(work_persons::person_id.eq(&person.person_id));
+                    }
+
+                    if let Some(person) = &query.performer {
+                        statement = statement.filter(
+                            recording_persons::person_id
+                                .eq(&person.person_id)
+                                .or(ensemble_persons::person_id.eq(&person.person_id)),
+                        );
+                    }
+
+                    if let Some(instrument) = &query.instrument {
+                        statement = statement.filter(
+                            work_instruments::instrument_id
+                                .eq(&instrument.instrument_id)
+                                .or(recording_persons::instrument_id.eq(&instrument.instrument_id))
+                                .or(ensemble_persons::instrument_id.eq(&instrument.instrument_id)),
+                        );
+                    }
+
+                    if let Some(ensemble) = &query.ensemble {
+                        statement = statement
+                            .filter(recording_ensembles::ensemble_id.eq(&ensemble.ensemble_id));
+                    }
+
+                    statement
                         .limit(9)
                         .select(works::all_columns)
                         .distinct()
                         .load::<tables::Work>(connection)?
                         .into_iter()
                         .map(|w| Work::from_table(w, connection))
-                    .collect::<Result<Vec<Work>>>()?;
+                        .collect::<Result<Vec<Work>>>()?
+                } else {
+                    Vec::new()
+                };
+
+                // Only search recordings in special cases. Works will always be searched and
+                // directly lead to recordings. The special case of a work in the query is already
+                // handled in another branch of the top-level match expression.
+                let recordings = if query.performer.is_some() || query.ensemble.is_some() {
+                    let mut statement = recordings::table
+                        .inner_join(
+                            works::table
+                                .left_join(work_persons::table)
+                                .left_join(work_instruments::table),
+                        )
+                        .left_join(recording_persons::table)
+                        .left_join(
+                            recording_ensembles::table
+                                .inner_join(ensembles::table.left_join(ensemble_persons::table)),
+                        )
+                        .filter(works::name.like(&search))
+                        .into_boxed();
+
+                    if let Some(person) = &query.composer {
+                        statement = statement.filter(work_persons::person_id.eq(&person.person_id));
+                    }
+
+                    if let Some(person) = &query.performer {
+                        statement = statement.filter(
+                            recording_persons::person_id
+                                .eq(&person.person_id)
+                                .or(ensemble_persons::person_id.eq(&person.person_id)),
+                        );
+                    }
+
+                    if let Some(instrument) = &query.instrument {
+                        statement = statement.filter(
+                            work_instruments::instrument_id
+                                .eq(&instrument.instrument_id)
+                                .or(recording_persons::instrument_id.eq(&instrument.instrument_id))
+                                .or(ensemble_persons::instrument_id.eq(&instrument.instrument_id)),
+                        );
+                    }
+
+                    if let Some(ensemble) = &query.ensemble {
+                        statement = statement
+                            .filter(recording_ensembles::ensemble_id.eq(&ensemble.ensemble_id));
+                    }
+
+                    statement
+                        .limit(9)
+                        .select(recordings::all_columns)
+                        .distinct()
+                        .load::<tables::Recording>(connection)?
+                        .into_iter()
+                        .map(|r| Recording::from_table(r, connection))
+                        .collect::<Result<Vec<Recording>>>()?
+                } else {
+                    Vec::new()
+                };
+
+                let mut statement = albums::table
+                    .inner_join(
+                        album_recordings::table.inner_join(
+                            recordings::table
+                                .inner_join(
+                                    works::table
+                                        .left_join(work_persons::table)
+                                        .left_join(work_instruments::table),
+                                )
+                                .left_join(recording_persons::table)
+                                .left_join(recording_ensembles::table.inner_join(
+                                    ensembles::table.left_join(ensemble_persons::table),
+                                )),
+                        ),
+                    )
+                    .filter(albums::name.like(&search))
+                    .into_boxed();
+
+                if let Some(person) = &query.composer {
+                    statement = statement.filter(work_persons::person_id.eq(&person.person_id));
+                }
+
+                if let Some(person) = &query.performer {
+                    statement = statement.filter(
+                        recording_persons::person_id
+                            .eq(&person.person_id)
+                            .or(ensemble_persons::person_id.eq(&person.person_id)),
+                    );
+                }
+
+                if let Some(instrument) = &query.instrument {
+                    statement = statement.filter(
+                        work_instruments::instrument_id
+                            .eq(&instrument.instrument_id)
+                            .or(recording_persons::instrument_id.eq(&instrument.instrument_id))
+                            .or(ensemble_persons::instrument_id.eq(&instrument.instrument_id)),
+                    );
+                }
+
+                if let Some(ensemble) = &query.ensemble {
+                    statement = statement
+                        .filter(recording_ensembles::ensemble_id.eq(&ensemble.ensemble_id));
+                }
+
+                let albums = statement
+                    .limit(9)
+                    .select(albums::all_columns)
+                    .distinct()
+                    .load::<tables::Album>(connection)?
+                    .into_iter()
+                    .map(|r| Album::from_table(r, connection))
+                    .collect::<Result<Vec<Album>>>()?;
 
                 LibraryResults {
+                    composers,
                     performers,
                     ensembles,
+                    instruments,
                     works,
-                    ..Default::default()
-                }
-            }
-            LibraryQuery {
-                composer: None,
-                performer: None,
-                ensemble: Some(ensemble),
-                work: None,
-                ..
-            } => {
-                let composers: Vec<Person> =
-                    persons::table
-                        .inner_join(work_persons::table.inner_join(
-                            works::table.inner_join(
-                                recordings::table.inner_join(recording_ensembles::table),
-                            ),
-                        ))
-                        .filter(
-                            recording_ensembles::ensemble_id
-                                .eq(&ensemble.ensemble_id)
-                                .and(persons::name.like(&search)),
-                        )
-                        .limit(9)
-                        .select(persons::all_columns)
-                        .distinct()
-                        .load(connection)?;
-
-                let recordings = recordings::table
-                    .inner_join(
-                        works::table.left_join(work_persons::table.inner_join(persons::table)),
-                    )
-                    // .inner_join(recording_persons::table.inner_join(persons::table))
-                    .inner_join(recording_ensembles::table)
-                    .filter(
-                        recording_ensembles::ensemble_id
-                            .eq(&ensemble.ensemble_id)
-                            .and(works::name.like(&search).or(persons::name.like(&search))),
-                    )
-                    .select(recordings::all_columns)
-                    .distinct()
-                    .load::<tables::Recording>(connection)?
-                    .into_iter()
-                    .map(|r| Recording::from_table(r, connection))
-                    .collect::<Result<Vec<Recording>>>()?;
-
-                let albums = albums::table
-                    .inner_join(
-                        album_recordings::table
-                            .inner_join(recordings::table.inner_join(recording_ensembles::table)),
-                    )
-                    .filter(
-                        recording_ensembles::ensemble_id
-                            .eq(&ensemble.ensemble_id)
-                            .and(albums::name.like(&search)),
-                    )
-                    .select(albums::all_columns)
-                    .distinct()
-                    .load::<tables::Album>(connection)?
-                    .into_iter()
-                    .map(|a| Album::from_table(a, connection))
-                    .collect::<Result<Vec<Album>>>()?;
-
-                LibraryResults {
-                    composers,
                     recordings,
                     albums,
                     ..Default::default()
                 }
             }
-            LibraryQuery {
-                composer: None,
-                performer: Some(performer),
-                work: None,
-                ..
-            } => {
-                let composers: Vec<Person> = persons::table
-                    .inner_join(
-                        work_persons::table
-                            .inner_join(works::table.inner_join(
-                                recordings::table.inner_join(recording_persons::table),
-                            )),
-                    )
-                    .filter(
-                        recording_persons::person_id
-                            .eq(&performer.person_id)
-                            .and(persons::name.like(&search)),
-                    )
-                    .limit(9)
-                    .select(persons::all_columns)
-                    .distinct()
-                    .load(connection)?;
-
-                let recordings = recordings::table
-                    .inner_join(
-                        works::table.left_join(work_persons::table.inner_join(persons::table)),
-                    )
-                    .inner_join(recording_persons::table)
-                    .filter(
-                        recording_persons::person_id
-                            .eq(&performer.person_id)
-                            .and(works::name.like(&search).or(persons::name.like(&search))),
-                    )
-                    .select(recordings::all_columns)
-                    .distinct()
-                    .load::<tables::Recording>(connection)?
-                    .into_iter()
-                    .map(|r| Recording::from_table(r, connection))
-                    .collect::<Result<Vec<Recording>>>()?;
-
-                let albums = albums::table
-                    .inner_join(
-                        album_recordings::table
-                            .inner_join(recordings::table.inner_join(recording_persons::table)),
-                    )
-                    .filter(
-                        recording_persons::person_id
-                            .eq(&performer.person_id)
-                            .and(albums::name.like(&search)),
-                    )
-                    .select(albums::all_columns)
-                    .distinct()
-                    .load::<tables::Album>(connection)?
-                    .into_iter()
-                    .map(|a| Album::from_table(a, connection))
-                    .collect::<Result<Vec<Album>>>()?;
-
-                LibraryResults {
-                    composers,
-                    recordings,
-                    albums,
-                    ..Default::default()
-                }
-            }
-            LibraryQuery {
-                composer: Some(composer),
-                ensemble: Some(ensemble),
-                work: None,
-                ..
-            } => {
-                let recordings = recordings::table
-                    .inner_join(works::table.inner_join(work_persons::table))
-                    .inner_join(recording_ensembles::table)
-                    .filter(
-                        work_persons::person_id
-                            .eq(&composer.person_id)
-                            .and(recording_ensembles::ensemble_id.eq(&ensemble.ensemble_id))
-                            .and(works::name.like(search)),
-                    )
-                    .select(recordings::all_columns)
-                    .distinct()
-                    .load::<tables::Recording>(connection)?
-                    .into_iter()
-                    .map(|r| Recording::from_table(r, connection))
-                    .collect::<Result<Vec<Recording>>>()?;
-
-                LibraryResults {
-                    recordings,
-                    ..Default::default()
-                }
-            }
-            LibraryQuery {
-                composer: Some(composer),
-                performer: Some(performer),
-                work: None,
-                ..
-            } => {
-                let recordings = recordings::table
-                    .inner_join(works::table.inner_join(work_persons::table))
-                    .inner_join(recording_persons::table)
-                    .filter(
-                        work_persons::person_id
-                            .eq(&composer.person_id)
-                            .and(recording_persons::person_id.eq(&performer.person_id))
-                            .and(works::name.like(search)),
-                    )
-                    .select(recordings::all_columns)
-                    .distinct()
-                    .load::<tables::Recording>(connection)?
-                    .into_iter()
-                    .map(|r| Recording::from_table(r, connection))
-                    .collect::<Result<Vec<Recording>>>()?;
-
-                LibraryResults {
-                    recordings,
-                    ..Default::default()
-                }
-            }
             LibraryQuery {
                 work: Some(work), ..
             } => {
@@ -414,30 +453,57 @@ impl Library {
         let mut binding = self.imp().connection.borrow_mut();
         let connection = &mut *binding.as_mut().unwrap();
 
+        let composer_id = program.composer_id();
+        let performer_id = program.performer_id();
+        let ensemble_id = program.ensemble_id();
+        let instrument_id = program.instrument_id();
+        let work_id = program.work_id();
+        let album_id = program.album_id();
+
         let mut query = recordings::table
-            .inner_join(works::table.left_join(work_persons::table))
+            .inner_join(
+                works::table
+                    .left_join(work_persons::table)
+                    .left_join(work_instruments::table),
+            )
             .left_join(recording_persons::table)
-            .left_join(recording_ensembles::table)
+            .left_join(
+                recording_ensembles::table
+                    .left_join(ensembles::table.inner_join(ensemble_persons::table)),
+            )
             .left_join(album_recordings::table)
             .into_boxed();
 
-        if let Some(composer_id) = program.composer_id() {
+        if let Some(composer_id) = &composer_id {
             query = query.filter(work_persons::person_id.eq(composer_id));
         }
 
-        if let Some(performer_id) = program.performer_id() {
+        if let Some(performer_id) = &performer_id {
-            query = query.filter(recording_persons::person_id.eq(performer_id));
+            query = query.filter(
+                recording_persons::person_id
+                    .eq(performer_id)
+                    .or(ensemble_persons::person_id.eq(performer_id)),
+            );
         }
 
-        if let Some(ensemble_id) = program.ensemble_id() {
+        if let Some(ensemble_id) = &ensemble_id {
             query = query.filter(recording_ensembles::ensemble_id.eq(ensemble_id));
         }
 
-        if let Some(work_id) = program.work_id() {
+        if let Some(instrument_id) = &instrument_id {
+            query = query.filter(
+                work_instruments::instrument_id
+                    .eq(instrument_id)
+                    .or(recording_persons::instrument_id.eq(instrument_id))
+                    .or(ensemble_persons::instrument_id.eq(instrument_id)),
+            );
+        }
+
+        if let Some(work_id) = &work_id {
             query = query.filter(recordings::work_id.eq(work_id));
         }
 
-        if let Some(album_id) = program.album_id() {
+        if let Some(album_id) = &album_id {
             query = query.filter(album_recordings::album_id.eq(album_id));
         }
 
@@ -448,6 +514,7 @@ impl Library {
         let row = query
             .order(random())
             .select(tables::Recording::as_select())
+            .distinct()
             .first::<tables::Recording>(connection)?;
 
         Recording::from_table(row, connection)
@@ -1479,6 +1546,7 @@ pub struct LibraryQuery {
     pub composer: Option<Person>,
     pub performer: Option<Person>,
     pub ensemble: Option<Ensemble>,
+    pub instrument: Option<Instrument>,
     pub work: Option<Work>,
     pub search: String,
 }
@@ -1488,6 +1556,7 @@ impl LibraryQuery {
         self.composer.is_none()
             && self.performer.is_none()
             && self.ensemble.is_none()
+            && self.instrument.is_none()
             && self.work.is_none()
             && self.search.is_empty()
     }
@@ -1498,6 +1567,7 @@ pub struct LibraryResults {
     pub composers: Vec<Person>,
     pub performers: Vec<Person>,
     pub ensembles: Vec<Ensemble>,
+    pub instruments: Vec<Instrument>,
     pub works: Vec<Work>,
     pub recordings: Vec<Recording>,
     pub albums: Vec<Album>,
@@ -1508,6 +1578,7 @@ impl LibraryResults {
         self.composers.is_empty()
             && self.performers.is_empty()
             && self.ensembles.is_empty()
+            && self.instruments.is_empty()
             && self.works.is_empty()
             && self.recordings.is_empty()
             && self.albums.is_empty()

src/program.rs

@@ -30,6 +30,9 @@ mod imp {
         #[property(get, set)]
         pub ensemble_id: RefCell<Option<String>>,
 
+        #[property(get, set)]
+        pub instrument_id: RefCell<Option<String>>,
+
         #[property(get, set)]
         pub work_id: RefCell<Option<String>>,
 
@@ -74,6 +77,7 @@ impl Program {
             .property("composer-id", query.composer.map(|p| p.person_id))
             .property("performer-id", query.performer.map(|p| p.person_id))
             .property("ensemble-id", query.ensemble.map(|e| e.ensemble_id))
+            .property("instrument-id", query.instrument.map(|i| i.instrument_id))
             .property("prefer-recently-added", 0.25)
             .property("prefer-least-recently-played", 0.5)
             .property("play-full-recordings", true)

src/search_entry.rs

@@ -211,6 +211,7 @@ impl SearchEntry {
                 Tag::Composer(person) => query.composer = Some(person),
                 Tag::Performer(person) => query.performer = Some(person),
                 Tag::Ensemble(ensemble) => query.ensemble = Some(ensemble),
+                Tag::Instrument(instrument) => query.instrument = Some(instrument),
                 Tag::Work(work) => query.work = Some(work),
             }
         }

src/search_tag.rs

@@ -3,7 +3,7 @@ use std::cell::OnceCell;
 use adw::{glib, glib::subclass::Signal, prelude::*, subclass::prelude::*};
 use once_cell::sync::Lazy;
 
-use crate::db::models::{Ensemble, Person, Work};
+use crate::db::models::{Ensemble, Instrument, Person, Work};
 
 mod imp {
     use super::*;
@@ -55,13 +55,16 @@ impl SearchTag {
     pub fn new(tag: Tag) -> Self {
         let obj: SearchTag = glib::Object::new();
 
-        obj.imp().label.set_label(match &tag {
+        let label = match &tag {
             Tag::Composer(person) => person.name.get(),
             Tag::Performer(person) => person.name.get(),
             Tag::Ensemble(ensemble) => ensemble.name.get(),
+            Tag::Instrument(instrument) => instrument.name.get(),
             Tag::Work(work) => work.name.get(),
-        });
+        };
 
+        obj.imp().label.set_label(label);
+        obj.set_tooltip_text(Some(label));
         obj.imp().tag.set(tag).unwrap();
 
         obj
@@ -90,5 +93,6 @@ pub enum Tag {
     Composer(Person),
     Performer(Person),
     Ensemble(Ensemble),
+    Instrument(Instrument),
     Work(Work),
 }

src/tag_tile.rs

@@ -55,6 +55,9 @@ impl TagTile {
             Tag::Ensemble(ensemble) => {
                 imp.title_label.set_label(ensemble.name.get());
             }
+            Tag::Instrument(instrument) => {
+                imp.title_label.set_label(instrument.name.get());
+            }
             Tag::Work(work) => {
                 imp.title_label.set_label(work.name.get());
                 if let Some(composers) = work.composers_string() {