jadb/lib/search/word_search/data_query.dart

import 'package:jadb/_data_ingestion/jmdict/table_names.dart';
import 'package:jadb/_data_ingestion/tanos-jlpt/table_names.dart';
import 'package:jadb/util/sqlite_utils.dart';
import 'package:sqflite_common/sqflite.dart';

class LinearWordQueryData {
  final List<Map<String, Object?>> senses;
  final List<Map<String, Object?>> readingElements;
  final List<Map<String, Object?>> kanjiElements;
  final List<Map<String, Object?>> jlptTags;
  final List<Map<String, Object?>> commonEntries;
  final List<Map<String, Object?>> senseAntonyms;
  final List<Map<String, Object?>> senseDialects;
  final List<Map<String, Object?>> senseFields;
  final List<Map<String, Object?>> senseGlossaries;
  final List<Map<String, Object?>> senseInfos;
  final List<Map<String, Object?>> senseLanguageSources;
  final List<Map<String, Object?>> senseMiscs;
  final List<Map<String, Object?>> sensePOSs;
  final List<Map<String, Object?>> senseRestrictedToKanjis;
  final List<Map<String, Object?>> senseRestrictedToReadings;
  final List<Map<String, Object?>> senseSeeAlsos;
  final List<Map<String, Object?>> exampleSentences;
  final List<Map<String, Object?>> readingElementInfos;
  final List<Map<String, Object?>> readingElementRestrictions;
  final List<Map<String, Object?>> kanjiElementInfos;

  const LinearWordQueryData({
    required this.senses,
    required this.readingElements,
    required this.kanjiElements,
    required this.jlptTags,
    required this.commonEntries,
    required this.senseAntonyms,
    required this.senseDialects,
    required this.senseFields,
    required this.senseGlossaries,
    required this.senseInfos,
    required this.senseLanguageSources,
    required this.senseMiscs,
    required this.sensePOSs,
    required this.senseRestrictedToKanjis,
    required this.senseRestrictedToReadings,
    required this.senseSeeAlsos,
    required this.exampleSentences,
    required this.readingElementInfos,
    required this.readingElementRestrictions,
    required this.kanjiElementInfos,
  });
}

Future<LinearWordQueryData> fetchLinearWordQueryData(
  DatabaseExecutor connection,
  List<int> entryIds,
) async {
  late final List<Map<String, Object?>> senses;
  final Future<List<Map<String, Object?>>> senses_query = connection.query(
    JMdictTableNames.sense,
    where: 'entryId IN (${List.filled(entryIds.length, '?').join(',')})',
    whereArgs: entryIds,
  );

  late final List<Map<String, Object?>> readingElements;
  final Future<List<Map<String, Object?>>> readingElements_query =
      connection.query(
    JMdictTableNames.readingElement,
    where: 'entryId IN (${List.filled(entryIds.length, '?').join(',')})',
    whereArgs: entryIds,
    orderBy: 'orderNum',
  );

  late final List<Map<String, Object?>> kanjiElements;
  final Future<List<Map<String, Object?>>> kanjiElements_query =
      connection.query(
    JMdictTableNames.kanjiElement,
    where: 'entryId IN (${List.filled(entryIds.length, '?').join(',')})',
    whereArgs: entryIds,
    orderBy: 'orderNum',
  );

  late final List<Map<String, Object?>> jlptTags;
  final Future<List<Map<String, Object?>>> jlptTags_query = connection.query(
    TanosJLPTTableNames.jlptTag,
    where: 'entryId IN (${List.filled(entryIds.length, '?').join(',')})',
    whereArgs: entryIds,
  );

  late final List<Map<String, Object?>> commonEntries;
  final Future<List<Map<String, Object?>>> commonEntries_query =
      connection.query(
    'JMdict_EntryCommon',
    where: 'entryId IN (${List.filled(entryIds.length, '?').join(',')})',
    whereArgs: entryIds,
  );

  await Future.wait([
    senses_query.then((value) => senses = value),
    readingElements_query.then((value) => readingElements = value),
    kanjiElements_query.then((value) => kanjiElements = value),
    jlptTags_query.then((value) => jlptTags = value),
    commonEntries_query.then((value) => commonEntries = value),
  ]);

  // Sense queries

  final senseIds = senses.map((sense) => sense['senseId'] as int).toList();

  late final List<Map<String, Object?>> senseAntonyms;
  final Future<List<Map<String, Object?>>> senseAntonyms_query =
      connection.rawQuery(
    """
        SELECT
          "${JMdictTableNames.senseAntonyms}".senseId,
          "${JMdictTableNames.senseAntonyms}".ambiguous,
          "${JMdictTableNames.senseAntonyms}".xrefEntryId,
          "JMdict_BaseAndFurigana"."base",
          "JMdict_BaseAndFurigana"."furigana"
        FROM "${JMdictTableNames.senseAntonyms}"
        JOIN "JMdict_BaseAndFurigana"
          ON "${JMdictTableNames.senseAntonyms}"."xrefEntryId" = "JMdict_BaseAndFurigana"."entryId"
        WHERE
          "senseId" IN (${List.filled(senseIds.length, '?').join(',')})
          AND "JMdict_BaseAndFurigana"."isFirst"
        ORDER BY
          "${JMdictTableNames.senseAntonyms}"."senseId",
          "${JMdictTableNames.senseAntonyms}"."xrefEntryId"
    """,
    [...senseIds],
  );

  late final List<Map<String, Object?>> senseDialects;
  final Future<List<Map<String, Object?>>> senseDialects_query =
      connection.query(
    JMdictTableNames.senseDialect,
    where: 'senseId IN (${List.filled(senseIds.length, '?').join(',')})',
    whereArgs: senseIds,
  );

  late final List<Map<String, Object?>> senseFields;
  final Future<List<Map<String, Object?>>> senseFields_query = connection.query(
    JMdictTableNames.senseField,
    where: 'senseId IN (${List.filled(senseIds.length, '?').join(',')})',
    whereArgs: senseIds,
  );

  late final List<Map<String, Object?>> senseGlossaries;
  final Future<List<Map<String, Object?>>> senseGlossaries_query =
      connection.query(
    JMdictTableNames.senseGlossary,
    where: 'senseId IN (${List.filled(senseIds.length, '?').join(',')})',
    whereArgs: senseIds,
  );

  late final List<Map<String, Object?>> senseInfos;
  final Future<List<Map<String, Object?>>> senseInfos_query = connection.query(
    JMdictTableNames.senseInfo,
    where: 'senseId IN (${List.filled(senseIds.length, '?').join(',')})',
    whereArgs: senseIds,
  );

  late final List<Map<String, Object?>> senseLanguageSources;
  final Future<List<Map<String, Object?>>> senseLanguageSources_query =
      connection.query(
    JMdictTableNames.senseLanguageSource,
    where: 'senseId IN (${List.filled(senseIds.length, '?').join(',')})',
    whereArgs: senseIds,
  );

  late final List<Map<String, Object?>> senseMiscs;
  final Future<List<Map<String, Object?>>> senseMiscs_query = connection.query(
    JMdictTableNames.senseMisc,
    where: 'senseId IN (${List.filled(senseIds.length, '?').join(',')})',
    whereArgs: senseIds,
  );

  late final List<Map<String, Object?>> sensePOSs;
  final Future<List<Map<String, Object?>>> sensePOSs_query = connection.query(
    JMdictTableNames.sensePOS,
    where: 'senseId IN (${List.filled(senseIds.length, '?').join(',')})',
    whereArgs: senseIds,
  );

  late final List<Map<String, Object?>> senseRestrictedToKanjis;
  final Future<List<Map<String, Object?>>> senseRestrictedToKanjis_query =
      connection.query(
    JMdictTableNames.senseRestrictedToKanji,
    where: 'senseId IN (${List.filled(senseIds.length, '?').join(',')})',
    whereArgs: senseIds,
  );

  late final List<Map<String, Object?>> senseRestrictedToReadings;
  final Future<List<Map<String, Object?>>> senseRestrictedToReadings_query =
      connection.query(
    JMdictTableNames.senseRestrictedToReading,
    where: 'senseId IN (${List.filled(senseIds.length, '?').join(',')})',
    whereArgs: senseIds,
  );

  late final List<Map<String, Object?>> senseSeeAlsos;
  final Future<List<Map<String, Object?>>> senseSeeAlsos_query =
      connection.rawQuery(
    """
        SELECT
          "${JMdictTableNames.senseSeeAlso}"."senseId",
          "${JMdictTableNames.senseSeeAlso}"."ambiguous",
          "${JMdictTableNames.senseSeeAlso}"."xrefEntryId",
          "JMdict_BaseAndFurigana"."base",
          "JMdict_BaseAndFurigana"."furigana"
        FROM "${JMdictTableNames.senseSeeAlso}"
        JOIN "JMdict_BaseAndFurigana"
          ON "${JMdictTableNames.senseSeeAlso}"."xrefEntryId" = "JMdict_BaseAndFurigana"."entryId"
        WHERE
          "senseId" IN (${List.filled(senseIds.length, '?').join(',')})
          AND "JMdict_BaseAndFurigana"."isFirst"
        ORDER BY
          "${JMdictTableNames.senseSeeAlso}"."senseId",
          "${JMdictTableNames.senseSeeAlso}"."xrefEntryId"
    """,
    [...senseIds],
  );

  late final List<Map<String, Object?>> exampleSentences;
  final Future<List<Map<String, Object?>>> exampleSentences_query =
      connection.query(
    'JMdict_ExampleSentence',
    where: 'senseId IN (${List.filled(senseIds.length, '?').join(',')})',
    whereArgs: senseIds,
  );

  // Reading queries

  final readingIds = readingElements
      .map((element) => (
            element['entryId'] as int,
            escapeStringValue(element['reading'] as String)
          ))
      .toList();

  late final List<Map<String, Object?>> readingElementInfos;
  final Future<List<Map<String, Object?>>> readingElementInfos_query =
      connection.query(
    JMdictTableNames.readingInfo,
    where: '(entryId, reading) IN (${readingIds.join(',')})',
  );

  late final List<Map<String, Object?>> readingElementRestrictions;
  final Future<List<Map<String, Object?>>> readingElementRestrictions_query =
      connection.query(
    JMdictTableNames.readingRestriction,
    where: '(entryId, reading) IN (${readingIds.join(',')})',
  );

  // Kanji queries

  final kanjiIds = kanjiElements
      .map((element) => (
            element['entryId'] as int,
            escapeStringValue(element['reading'] as String)
          ))
      .toList();

  late final List<Map<String, Object?>> kanjiElementInfos;
  final Future<List<Map<String, Object?>>> kanjiElementInfos_query =
      connection.query(
    JMdictTableNames.kanjiInfo,
    where: '(entryId, reading) IN (${kanjiIds.join(',')})',
  );

  await Future.wait([
    senseAntonyms_query.then((value) => senseAntonyms = value),
    senseDialects_query.then((value) => senseDialects = value),
    senseFields_query.then((value) => senseFields = value),
    senseGlossaries_query.then((value) => senseGlossaries = value),
    senseInfos_query.then((value) => senseInfos = value),
    senseLanguageSources_query.then((value) => senseLanguageSources = value),
    senseMiscs_query.then((value) => senseMiscs = value),
    sensePOSs_query.then((value) => sensePOSs = value),
    senseRestrictedToKanjis_query
        .then((value) => senseRestrictedToKanjis = value),
    senseRestrictedToReadings_query
        .then((value) => senseRestrictedToReadings = value),
    senseSeeAlsos_query.then((value) => senseSeeAlsos = value),
    exampleSentences_query.then((value) => exampleSentences = value),
    readingElementInfos_query.then((value) => readingElementInfos = value),
    readingElementRestrictions_query
        .then((value) => readingElementRestrictions = value),
    kanjiElementInfos_query.then((value) => kanjiElementInfos = value),
  ]);

  return LinearWordQueryData(
    senses: senses,
    readingElements: readingElements,
    kanjiElements: kanjiElements,
    jlptTags: jlptTags,
    commonEntries: commonEntries,
    senseAntonyms: senseAntonyms,
    senseDialects: senseDialects,
    senseFields: senseFields,
    senseGlossaries: senseGlossaries,
    senseInfos: senseInfos,
    senseLanguageSources: senseLanguageSources,
    senseMiscs: senseMiscs,
    sensePOSs: sensePOSs,
    senseRestrictedToKanjis: senseRestrictedToKanjis,
    senseRestrictedToReadings: senseRestrictedToReadings,
    senseSeeAlsos: senseSeeAlsos,
    exampleSentences: exampleSentences,
    readingElementInfos: readingElementInfos,
    readingElementRestrictions: readingElementRestrictions,
    kanjiElementInfos: kanjiElementInfos,
  );
}