client: Rename to database

database/lib/musicus_database.dart

@@ -0,0 +1,2 @@
+export 'src/database.dart';
+export 'src/info.dart';

database/lib/src/database.dart

@@ -0,0 +1,206 @@
+import 'dart:math';
+
+import 'package:drift/drift.dart';
+
+import 'info.dart';
+
+part 'database.g.dart';
+
+final _random = Random(DateTime.now().millisecondsSinceEpoch);
+
+/// Generate a random ID suitable for use as primary key.
+int generateId() => _random.nextInt(0xFFFFFFFF);
+
+/// The database for storing all metadata for the music library.
+///
+/// This also handles synchronization with a Musicus server.
+@DriftDatabase(include: {'database.drift'})
+class MusicusClientDatabase extends _$MusicusClientDatabase {
+  /// The number of items contained in one result page.
+  static const pageSize = 50;
+
+  @override
+  int get schemaVersion => 1;
+
+  @override
+  MigrationStrategy get migration => MigrationStrategy(
+        beforeOpen: (details) async {
+          await customStatement('PRAGMA foreign_keys = ON;');
+        },
+      );
+
+  MusicusClientDatabase({
+    @required QueryExecutor executor,
+  }) : super(executor);
+
+  MusicusClientDatabase.connect({
+    @required DatabaseConnection connection,
+  }) : super.connect(connection);
+
+
+  /// Get all available persons.
+  ///
+  /// This will return a list of [pageSize] persons. You can get another page
+  /// using the [page] parameter. If a non empty [search] string is provided,
+  /// the persons will get filtered based on that string.
+  Future<List<Person>> getPersons([int page, String search]) async {
+    final offset = page != null ? page * pageSize : 0;
+    List<Person> result;
+
+    if (search == null || search.isEmpty) {
+      result = await allPersons(pageSize, offset).get();
+    } else {
+      result = await searchPersons('$search%', pageSize, offset).get();
+    }
+
+    return result;
+  }
+
+  /// Get all available instruments.
+  ///
+  /// This will return a list of [pageSize] instruments. You can get another
+  /// page using the [page] parameter. If a non empty [search] string is
+  /// provided, the instruments will get filtered based on that string.
+  Future<List<Instrument>> getInstruments([int page, String search]) async {
+    final offset = page != null ? page * pageSize : 0;
+    List<Instrument> result;
+
+    if (search == null || search.isEmpty) {
+      result = await allInstruments(pageSize, offset).get();
+    } else {
+      result = await searchInstruments('$search%', pageSize, offset).get();
+    }
+
+    return result;
+  }
+
+  /// Retrieve more information on an already queried work.
+  Future<WorkInfo> getWorkInfo(Work work) async {
+    final id = work.id;
+
+    final composers = await partComposersByWork(id).get();
+    composers.insert(0, await personById(work.composer).getSingle());
+    final instruments = await instrumentsByWork(id).get();
+
+    final List<PartInfo> parts = [];
+    for (final part in await partsByWork(id).get()) {
+      parts.add(PartInfo(
+        part: part,
+        composer: part.composer != null
+            ? await personById(part.composer).getSingle()
+            : null,
+        instruments: await instrumentsByWorkPart(part.id).get(),
+      ));
+    }
+
+    final List<WorkSection> sections = [];
+    for (final section in await sectionsByWork(id).get()) {
+      sections.add(section);
+    }
+
+    return WorkInfo(
+      work: work,
+      instruments: instruments,
+      composers: composers,
+      parts: parts,
+      sections: sections,
+    );
+  }
+
+  /// Get all available information on a work.
+  Future<WorkInfo> getWork(int id) async {
+    final work = await workById(id).getSingle();
+    return await getWorkInfo(work);
+  }
+
+  /// Get information on all works written by the person with ID [personId].
+  ///
+  /// This will return a list of [pageSize] results. You can get another page
+  /// using the [page] parameter. If a non empty [search] string is provided,
+  /// the works will be filtered using that string.
+  Future<List<WorkInfo>> getWorks(int personId,
+      [int page, String search]) async {
+    final offset = page != null ? page * pageSize : 0;
+    List<Work> works;
+
+    if (search == null || search.isEmpty) {
+      works = await worksByComposer(personId, pageSize, offset).get();
+    } else {
+      works =
+          await searchWorksByComposer(personId, '$search%', pageSize, offset)
+              .get();
+    }
+
+    final List<WorkInfo> result = [];
+    for (final work in works) {
+      result.add(await getWorkInfo(work));
+    }
+
+    return result;
+  }
+
+  /// Get all available ensembles.
+  ///
+  /// This will return a list of [pageSize] ensembles. You can get another page
+  /// using the [page] parameter. If a non empty [search] string is provided,
+  /// the ensembles will get filtered based on that string.
+  Future<List<Ensemble>> getEnsembles([int page, String search]) async {
+    final offset = page != null ? page * pageSize : 0;
+    List<Ensemble> result;
+
+    if (search == null || search.isEmpty) {
+      result = await allEnsembles(pageSize, offset).get();
+    } else {
+      result = await searchEnsembles('$search%', pageSize, offset).get();
+    }
+
+    return result;
+  }
+
+  /// Retreive more information on an already queried recording.
+  Future<RecordingInfo> getRecordingInfo(Recording recording) async {
+    final id = recording.id;
+
+    final List<PerformanceInfo> performances = [];
+    for (final performance in await performancesByRecording(id).get()) {
+      performances.add(PerformanceInfo(
+        person: performance.person != null
+            ? await personById(performance.person).getSingle()
+            : null,
+        ensemble: performance.ensemble != null
+            ? await ensembleById(performance.ensemble).getSingle()
+            : null,
+        role: performance.role != null
+            ? await instrumentById(performance.role).getSingle()
+            : null,
+      ));
+    }
+
+    return RecordingInfo(
+      recording: recording,
+      performances: performances,
+    );
+  }
+
+  /// Get all available information on a recording.
+  Future<RecordingInfo> getRecording(int id) async {
+    final recording = await recordingById(id).getSingle();
+    return await getRecordingInfo(recording);
+  }
+
+  /// Get information on all recordings of the work with ID [workId].
+  ///
+  /// This will return a list of [pageSize] recordings. You can get the other
+  /// pages using the [page] parameter.
+  Future<List<RecordingInfo>> getRecordings(int workId, [int page]) async {
+    final offset = page != null ? page * pageSize : 0;
+    final recordings = await recordingsByWork(workId, pageSize, offset).get();
+
+    final List<RecordingInfo> result = [];
+    for (final recording in recordings) {
+      result.add(await getRecordingInfo(recording));
+    }
+
+    return result;
+  }
+}

database/lib/src/database.drift

@@ -0,0 +1,139 @@
+CREATE TABLE persons (
+    id INTEGER NOT NULL PRIMARY KEY,
+    first_name TEXT NOT NULL,
+    last_name TEXT NOT NULL
+);
+
+-- This represents real instruments as well as other roles that can be played
+-- in a recording.
+CREATE TABLE instruments (
+    id INTEGER NOT NULL PRIMARY KEY,
+    name TEXT NOT NULL
+);
+
+CREATE TABLE works (
+    id INTEGER NOT NULL PRIMARY KEY,
+    composer INTEGER REFERENCES persons(id) ON DELETE SET NULL,
+    title TEXT NOT NULL
+);
+
+CREATE TABLE instrumentations (
+    work INTEGER NOT NULL REFERENCES works(id) ON DELETE CASCADE,
+    instrument INTEGER NOT NULL REFERENCES instruments(id) ON DELETE CASCADE
+);
+
+CREATE TABLE work_parts (
+    id INTEGER NOT NULL PRIMARY KEY,
+    composer INTEGER REFERENCES persons(id) ON DELETE SET NULL,
+    title TEXT NOT NULL,
+    part_of INTEGER NOT NULL REFERENCES works(id) ON DELETE CASCADE,
+    part_index INTEGER NOT NULL
+);
+
+CREATE TABLE part_instrumentations (
+    work_part INTEGER NOT NULL REFERENCES works(id) ON DELETE CASCADE,
+    instrument INTEGER NOT NULL REFERENCES instruments(id) ON DELETE CASCADE
+);
+
+CREATE TABLE work_sections (
+    id INTEGER NOT NULL PRIMARY KEY,
+    work INTEGER NOT NULL REFERENCES works(id) ON DELETE CASCADE,
+    title TEXT NOT NULL,
+    before_part_index INTEGER NOT NULL
+);
+
+CREATE TABLE ensembles (
+    id INTEGER NOT NULL PRIMARY KEY,
+    name TEXT NOT NULL
+);
+
+CREATE TABLE recordings (
+    id INTEGER NOT NULL PRIMARY KEY,
+    work INTEGER REFERENCES works(id) ON DELETE SET NULL,
+    comment TEXT NOT NULL
+);
+
+CREATE TABLE performances (
+    recording INTEGER NOT NULL REFERENCES recordings(id) ON DELETE CASCADE,
+    person INTEGER REFERENCES persons(id) ON DELETE CASCADE,
+    ensemble INTEGER REFERENCES ensembles(id) ON DELETE CASCADE,
+    role INTEGER REFERENCES instruments(id) ON DELETE SET NULL
+);
+
+allPersons:
+SELECT * FROM persons ORDER BY last_name, first_name
+    LIMIT :limit OFFSET :offset;
+
+searchPersons:
+SELECT * FROM persons WHERE last_name LIKE :search
+    ORDER BY last_name, first_name LIMIT :limit OFFSET :offset;
+
+personById:
+SELECT * FROM persons WHERE id = :id LIMIT 1;
+
+allInstruments:
+SELECT * FROM instruments ORDER BY name LIMIT :limit OFFSET :offset;
+
+searchInstruments:
+SELECT * FROM instruments WHERE name LIKE :search ORDER BY name
+    LIMIT :limit OFFSET :offset;
+
+instrumentById:
+SELECT * FROM instruments WHERE id = :id LIMIT 1;
+
+workById:
+SELECT * FROM works WHERE id = :id LIMIT 1;
+
+partsByWork:
+SELECT * FROM work_parts WHERE part_of = :id ORDER BY part_index;
+
+sectionsByWork:
+SELECT * FROM work_sections WHERE work = :id ORDER BY before_part_index;
+
+worksByComposer:
+SELECT DISTINCT works.* FROM works
+    JOIN work_parts ON work_parts.part_of = works.id
+    WHERE works.composer = :id OR work_parts.composer = :id
+    ORDER BY works.title LIMIT :limit OFFSET :offset;
+
+searchWorksByComposer:
+SELECT DISTINCT works.* FROM works
+    JOIN work_parts ON work_parts.part_of = works.id
+    WHERE (works.composer = :id OR work_parts.composer = :id)
+    AND works.title LIKE :search
+    ORDER BY works.title LIMIT :limit OFFSET :offset;
+
+partComposersByWork:
+SELECT DISTINCT persons.* FROM persons
+    JOIN work_parts ON work_parts.composer = persons.id
+    WHERE work_parts.part_of = :id;
+
+instrumentsByWork:
+SELECT instruments.* FROM instrumentations
+    JOIN instruments ON instrumentations.instrument = instruments.id
+    WHERE instrumentations.work = :workId;
+
+instrumentsByWorkPart:
+SELECT instruments.* FROM part_instrumentations
+    JOIN instruments ON part_instrumentations.instrument = instruments.id
+    WHERE part_instrumentations.work_part = :id;
+
+allEnsembles:
+SELECT * FROM ensembles ORDER BY name LIMIT :limit OFFSET :offset;
+
+searchEnsembles:
+SELECT * FROM ensembles WHERE name LIKE :search ORDER BY name
+    LIMIT :limit OFFSET :offset;
+
+ensembleById:
+SELECT * FROM ensembles WHERE id = :id LIMIT 1;
+
+recordingById:
+SELECT * FROM recordings WHERE id = :id;
+
+recordingsByWork:
+SELECT * FROM recordings WHERE work = :id ORDER BY id
+    LIMIT :limit OFFSET :offset;
+
+performancesByRecording:
+SELECT * FROM performances WHERE recording = :id;

database/lib/src/info.dart

@@ -0,0 +1,93 @@
+import 'database.dart';
+
+/// A bundle of all available information on a work part.
+class PartInfo {
+  /// The work part itself.
+  final WorkPart part;
+
+  /// A list of instruments.
+  ///
+  /// This will include the instruments, that are specific to this part.
+  final List<Instrument> instruments;
+
+  /// The composer of this part.
+  ///
+  /// This is null, if this part doesn't have a specific composer.
+  final Person composer;
+
+  PartInfo({
+    this.part,
+    this.instruments,
+    this.composer,
+  });
+}
+
+/// A bundle information on a work.
+///
+/// This includes all available information except for recordings of this work.
+class WorkInfo {
+  /// The work itself.
+  final Work work;
+
+  /// A list of instruments.
+  ///
+  /// This will not the include the instruments, that are specific to the work
+  /// parts.
+  final List<Instrument> instruments;
+
+  /// A list of persons, which will include all part composers.
+  final List<Person> composers;
+
+  /// All available information on the work parts.
+  final List<PartInfo> parts;
+
+  /// The sections of this work.
+  final List<WorkSection> sections;
+
+  WorkInfo({
+    this.work,
+    this.instruments,
+    this.composers,
+    this.parts,
+    this.sections,
+  });
+}
+
+/// All available information on a performance within a recording.
+class PerformanceInfo {
+  /// The performing person.
+  ///
+  /// This will be null, if this is an ensemble.
+  final Person person;
+
+  /// The performing ensemble.
+  ///
+  /// This will be null, if this is a person.
+  final Ensemble ensemble;
+
+  /// The instrument/role or null.
+  final Instrument role;
+
+  PerformanceInfo({
+    this.person,
+    this.ensemble,
+    this.role,
+  });
+}
+
+/// All available information on a recording.
+///
+/// This doesn't include the recorded work, because probably it's already
+/// available.
+class RecordingInfo {
+  /// The recording itself.
+  final Recording recording;
+
+  /// Information on the performances within this recording.
+  final List<PerformanceInfo> performances;
+
+  RecordingInfo({
+    this.recording,
+    this.performances,
+  });
+}