johrpan/musicus
1
0
Fork 0
mirror of https://github.com/johrpan/musicus.git synced 2025-10-26 11:47:25 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

library: New query logic

Browse source
This commit is contained in:
Elias Projahn 2025-03-01 20:54:22 +01:00
parent d96bdf56e2
commit a6e0935df8
7 changed files with 432 additions and 302 deletions
Download patch file Download diff file Expand all files Collapse all files

20
data/ui/home_page.blp
View file

@ -164,6 +164,26 @@ template $MusicusHomePage: Adw.NavigationPage {
child-activated => $tile_selected() swapped; 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 { Gtk.Label {
styles [ styles [
"heading" "heading"

31
src/home_page.rs
View file

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

665
src/library.rs
View file

@ -78,320 +78,359 @@ impl Library {
let connection = &mut *binding.as_mut().unwrap(); let connection = &mut *binding.as_mut().unwrap();
Ok(match query { 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)), .left_join(recording_persons::table),
) )
.and(persons::name.like(&search)), .left_join(work_instruments::table),
)
.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(
work_persons::person_id
.eq(&composer.person_id)
.and(persons::name.like(&search)),
)
.limit(9)
.select(persons::all_columns)
.distinct()
.load(connection)?;
let ensembles: Vec<Ensemble> = ensembles::table
.inner_join(recording_ensembles::table.inner_join(
recordings::table.inner_join(works::table.inner_join(work_persons::table)),
))
.filter(
work_persons::person_id
.eq(&composer.person_id)
.and(ensembles::name.like(&search)),
)
.limit(9)
.select(ensembles::all_columns)
.distinct()
.load::<tables::Ensemble>(connection)?
.into_iter()
.map(|e| Ensemble::from_table(e, connection))
.collect::<Result<Vec<Ensemble>>>()?;
let works: Vec<Work> = works::table
.inner_join(work_persons::table)
.filter(
work_persons::person_id
.eq(&composer.person_id)
.and(works::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>>>()?;
LibraryResults {
performers,
ensembles,
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)),
) )
.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) .limit(9)
.select(persons::all_columns) .select(persons::all_columns)
.distinct() .distinct()
.load(connection)?; .load::<Person>(connection)?
} else {
Vec::new()
};
let recordings = recordings::table let performers = if query.performer.is_none() {
let mut statement = persons::table
.inner_join(
recording_persons::table.inner_join(
recordings::table
.inner_join(
works::table
.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>>>()?
} else {
Vec::new()
};
let instruments = if query.instrument.is_none() {
let mut statement = instruments::table
.left_join(
work_instruments::table
.inner_join(works::table.left_join(work_persons::table)),
)
.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>>>()?
} 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( .inner_join(
works::table.left_join(work_persons::table.inner_join(persons::table)), 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),
)),
),
) )
// .inner_join(recording_persons::table.inner_join(persons::table)) .filter(albums::name.like(&search))
.inner_join(recording_ensembles::table) .into_boxed();
.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 if let Some(person) = &query.composer {
.inner_join( statement = statement.filter(work_persons::person_id.eq(&person.person_id));
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 { if let Some(person) = &query.performer {
composer: None, statement = statement.filter(
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 recording_persons::person_id
.eq(&performer.person_id) .eq(&person.person_id)
.and(persons::name.like(&search)), .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) .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) .select(albums::all_columns)
.distinct() .distinct()
.load::<tables::Album>(connection)? .load::<tables::Album>(connection)?
.into_iter() .into_iter()
.map(|a| Album::from_table(a, connection)) .map(|r| Album::from_table(r, connection))
.collect::<Result<Vec<Album>>>()?; .collect::<Result<Vec<Album>>>()?;
LibraryResults { LibraryResults {
composers, composers,
performers,
ensembles,
instruments,
works,
recordings, recordings,
albums, albums,
..Default::default() ..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 { LibraryQuery {
work: Some(work), .. work: Some(work), ..
} => { } => {
@ -414,30 +453,57 @@ impl Library {
let mut binding = self.imp().connection.borrow_mut(); let mut binding = self.imp().connection.borrow_mut();
let connection = &mut *binding.as_mut().unwrap(); 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 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_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) .left_join(album_recordings::table)
.into_boxed(); .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)); 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)); 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)); 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)); query = query.filter(album_recordings::album_id.eq(album_id));
} }
@ -448,6 +514,7 @@ impl Library {
let row = query let row = query
.order(random()) .order(random())
.select(tables::Recording::as_select()) .select(tables::Recording::as_select())
.distinct()
.first::<tables::Recording>(connection)?; .first::<tables::Recording>(connection)?;
Recording::from_table(row, connection) Recording::from_table(row, connection)
@ -1479,6 +1546,7 @@ pub struct LibraryQuery {
pub composer: Option<Person>, pub composer: Option<Person>,
pub performer: Option<Person>, pub performer: Option<Person>,
pub ensemble: Option<Ensemble>, pub ensemble: Option<Ensemble>,
pub instrument: Option<Instrument>,
pub work: Option<Work>, pub work: Option<Work>,
pub search: String, pub search: String,
} }
@ -1488,6 +1556,7 @@ impl LibraryQuery {
self.composer.is_none() self.composer.is_none()
&& self.performer.is_none() && self.performer.is_none()
&& self.ensemble.is_none() && self.ensemble.is_none()
&& self.instrument.is_none()
&& self.work.is_none() && self.work.is_none()
&& self.search.is_empty() && self.search.is_empty()
} }
@ -1498,6 +1567,7 @@ pub struct LibraryResults {
pub composers: Vec<Person>, pub composers: Vec<Person>,
pub performers: Vec<Person>, pub performers: Vec<Person>,
pub ensembles: Vec<Ensemble>, pub ensembles: Vec<Ensemble>,
pub instruments: Vec<Instrument>,
pub works: Vec<Work>, pub works: Vec<Work>,
pub recordings: Vec<Recording>, pub recordings: Vec<Recording>,
pub albums: Vec<Album>, pub albums: Vec<Album>,
@ -1508,6 +1578,7 @@ impl LibraryResults {
self.composers.is_empty() self.composers.is_empty()
&& self.performers.is_empty() && self.performers.is_empty()
&& self.ensembles.is_empty() && self.ensembles.is_empty()
&& self.instruments.is_empty()
&& self.works.is_empty() && self.works.is_empty()
&& self.recordings.is_empty() && self.recordings.is_empty()
&& self.albums.is_empty() && self.albums.is_empty()

4
src/program.rs
View file

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

1
src/search_entry.rs
View file

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

10
src/search_tag.rs
View file

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

3
src/tag_tile.rs
View file

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