jadb/lib/search/word_search/data_query.dart

import 'package:jadb/table_names/jmdict.dart';
import 'package:jadb/table_names/tanos_jlpt.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;

  final LinearWordQueryData? senseAntonymData;
  final LinearWordQueryData? senseSeeAlsoData;

  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,
    required this.senseAntonymData,
    required this.senseSeeAlsoData,
  });
}

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

Future<List<Map<String, Object?>>> _readingelementsQuery(
  DatabaseExecutor connection,
  List<int> entryIds,
) => connection.query(
  JMdictTableNames.readingElement,
  where: 'entryId IN (${List.filled(entryIds.length, '?').join(',')})',
  whereArgs: entryIds,
  orderBy: 'elementId',
);

Future<List<Map<String, Object?>>> _kanjielementsQuery(
  DatabaseExecutor connection,
  List<int> entryIds,
) => connection.query(
  JMdictTableNames.kanjiElement,
  where: 'entryId IN (${List.filled(entryIds.length, '?').join(',')})',
  whereArgs: entryIds,
  orderBy: 'elementId',
);

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

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

// Sense queries

Future<List<Map<String, Object?>>> _senseantonymsQuery(
  DatabaseExecutor connection,
  List<int> senseIds,
) => 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],
);

Future<List<Map<String, Object?>>> _senseseealsosQuery(
  DatabaseExecutor connection,
  List<int> senseIds,
) => 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],
);

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

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

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

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

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

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

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

Future<List<Map<String, Object?>>> _senserestrictedtokanjisQuery(
  DatabaseExecutor connection,
  List<int> senseIds,
) => connection.rawQuery(
  """
      SELECT
        "${JMdictTableNames.senseRestrictedToKanji}".senseId,
        "${JMdictTableNames.senseRestrictedToKanji}".kanjiElementId,
        "${JMdictTableNames.kanjiElement}".reading
      FROM "${JMdictTableNames.senseRestrictedToKanji}"
      JOIN "${JMdictTableNames.kanjiElement}"
        ON "${JMdictTableNames.senseRestrictedToKanji}"."kanjiElementId" = "${JMdictTableNames.kanjiElement}"."elementId"
      WHERE
        "senseId" IN (${List.filled(senseIds.length, '?').join(',')})
      ORDER BY
        "${JMdictTableNames.senseRestrictedToKanji}"."senseId",
        "${JMdictTableNames.senseRestrictedToKanji}"."kanjiElementId"
  """,
  [...senseIds],
);

Future<List<Map<String, Object?>>> _senserestrictedtoreadingsQuery(
  DatabaseExecutor connection,
  List<int> senseIds,
) => connection.rawQuery(
  """
      SELECT
        "${JMdictTableNames.senseRestrictedToReading}".senseId,
        "${JMdictTableNames.senseRestrictedToReading}".readingElementId,
        "${JMdictTableNames.readingElement}".reading
      FROM "${JMdictTableNames.senseRestrictedToReading}"
      JOIN "${JMdictTableNames.readingElement}"
        ON "${JMdictTableNames.senseRestrictedToReading}"."readingElementId" = "${JMdictTableNames.readingElement}"."elementId"
      WHERE
        "senseId" IN (${List.filled(senseIds.length, '?').join(',')})
      ORDER BY
        "${JMdictTableNames.senseRestrictedToReading}"."senseId",
        "${JMdictTableNames.senseRestrictedToReading}"."readingElementId"
  """,
  [...senseIds],
);

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

// Reading/kanji elements queries

Future<List<Map<String, Object?>>> _readingelementinfosQuery(
  DatabaseExecutor connection,
  List<int> readingIds,
) => connection.query(
  JMdictTableNames.readingInfo,
  where: '(elementId) IN (${List.filled(readingIds.length, '?').join(',')})',
  whereArgs: readingIds,
);

Future<List<Map<String, Object?>>> _readingelementrestrictionsQuery(
  DatabaseExecutor connection,
  List<int> readingIds,
) => connection.query(
  JMdictTableNames.readingRestriction,
  where: '(elementId) IN (${List.filled(readingIds.length, '?').join(',')})',
  whereArgs: readingIds,
);

Future<List<Map<String, Object?>>> _kanjielementinfosQuery(
  DatabaseExecutor connection,
  List<int> kanjiIds,
) => connection.query(
  JMdictTableNames.kanjiInfo,
  where: '(elementId) IN (${List.filled(kanjiIds.length, '?').join(',')})',
  whereArgs: kanjiIds,
);

// Xref queries

Future<LinearWordQueryData?> _senseantonymdataQuery(
  DatabaseExecutor connection,
  List<int> entryIds,
) => fetchLinearWordQueryData(connection, entryIds, fetchXrefData: false);

Future<LinearWordQueryData?> _senseseealsodataQuery(
  DatabaseExecutor connection,
  List<int> entryIds,
) => fetchLinearWordQueryData(connection, entryIds, fetchXrefData: false);

// Full query

Future<LinearWordQueryData> fetchLinearWordQueryData(
  DatabaseExecutor connection,
  List<int> entryIds, {
  bool fetchXrefData = true,
}) async {
  late final List<Map<String, Object?>> senses;
  late final List<Map<String, Object?>> readingElements;
  late final List<Map<String, Object?>> kanjiElements;
  late final List<Map<String, Object?>> jlptTags;
  late final List<Map<String, Object?>> commonEntries;

  await Future.wait([
    _sensesQuery(connection, entryIds).then((value) => senses = value),
    _readingelementsQuery(
      connection,
      entryIds,
    ).then((value) => readingElements = value),
    _kanjielementsQuery(
      connection,
      entryIds,
    ).then((value) => kanjiElements = value),
    _jlpttagsQuery(connection, entryIds).then((value) => jlptTags = value),
    _commonentriesQuery(
      connection,
      entryIds,
    ).then((value) => commonEntries = value),
  ]);

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

  late final List<Map<String, Object?>> senseAntonyms;
  late final List<Map<String, Object?>> senseDialects;
  late final List<Map<String, Object?>> senseFields;
  late final List<Map<String, Object?>> senseGlossaries;
  late final List<Map<String, Object?>> senseInfos;
  late final List<Map<String, Object?>> senseLanguageSources;
  late final List<Map<String, Object?>> senseMiscs;
  late final List<Map<String, Object?>> sensePOSs;
  late final List<Map<String, Object?>> senseRestrictedToKanjis;
  late final List<Map<String, Object?>> senseRestrictedToReadings;
  late final List<Map<String, Object?>> senseSeeAlsos;
  late final List<Map<String, Object?>> exampleSentences;

  final readingIds = readingElements
      .map((element) => element['elementId'] as int)
      .toList();

  final kanjiIds = kanjiElements
      .map((element) => element['elementId'] as int)
      .toList();

  late final List<Map<String, Object?>> readingElementInfos;
  late final List<Map<String, Object?>> readingElementRestrictions;

  late final List<Map<String, Object?>> kanjiElementInfos;

  // Xref data queries
  await Future.wait([
    _senseantonymsQuery(
      connection,
      senseIds,
    ).then((value) => senseAntonyms = value),
    _senseseealsosQuery(
      connection,
      senseIds,
    ).then((value) => senseSeeAlsos = value),
  ]);

  LinearWordQueryData? senseAntonymData;
  LinearWordQueryData? senseSeeAlsoData;

  await Future.wait([
    _sensedialectsQuery(
      connection,
      senseIds,
    ).then((value) => senseDialects = value),
    _sensefieldsQuery(
      connection,
      senseIds,
    ).then((value) => senseFields = value),
    _senseglossariesQuery(
      connection,
      senseIds,
    ).then((value) => senseGlossaries = value),
    _senseinfosQuery(connection, senseIds).then((value) => senseInfos = value),
    _senselanguagesourcesQuery(
      connection,
      senseIds,
    ).then((value) => senseLanguageSources = value),
    _sensemiscsQuery(connection, senseIds).then((value) => senseMiscs = value),
    _sensepossQuery(connection, senseIds).then((value) => sensePOSs = value),
    _senserestrictedtokanjisQuery(
      connection,
      senseIds,
    ).then((value) => senseRestrictedToKanjis = value),
    _senserestrictedtoreadingsQuery(
      connection,
      senseIds,
    ).then((value) => senseRestrictedToReadings = value),
    _examplesentencesQuery(
      connection,
      senseIds,
    ).then((value) => exampleSentences = value),
    _readingelementinfosQuery(
      connection,
      readingIds,
    ).then((value) => readingElementInfos = value),
    _readingelementrestrictionsQuery(
      connection,
      readingIds,
    ).then((value) => readingElementRestrictions = value),
    _kanjielementinfosQuery(
      connection,
      kanjiIds,
    ).then((value) => kanjiElementInfos = value),

    if (fetchXrefData)
      _senseantonymdataQuery(
        connection,
        senseAntonyms.map((antonym) => antonym['xrefEntryId'] as int).toList(),
      ).then((value) => senseAntonymData = value),

    if (fetchXrefData)
      _senseseealsodataQuery(
        connection,
        senseSeeAlsos.map((seeAlso) => seeAlso['xrefEntryId'] as int).toList(),
      ).then((value) => senseSeeAlsoData = 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,
    senseAntonymData: senseAntonymData,
    senseSeeAlsoData: senseSeeAlsoData,
  );
}