lib/search: generate list of ? instead of interpolation

lib/_data_ingestion/tanos-jlpt/resolve.dart

@@ -1,7 +1,6 @@
 import 'package:jadb/_data_ingestion/jmdict/table_names.dart';
 import 'package:jadb/_data_ingestion/tanos-jlpt/objects.dart';
 import 'package:jadb/_data_ingestion/tanos-jlpt/overrides.dart';
-import 'package:jadb/util/sqlite_utils.dart';
 import 'package:sqflite_common/sqlite_api.dart';
 
 Future<List<int>> _findReadingCandidates(
@@ -13,7 +12,8 @@ Future<List<int>> _findReadingCandidates(
           JMdictTableNames.readingElement,
           columns: ['entryId'],
           where:
-              'reading IN (${word.readings.map((e) => escapeStringValue(e)).join(',')})',
+              '"reading" IN (${List.filled(word.readings.length, '?').join(',')})',
+          whereArgs: [...word.readings],
         )
         .then((rows) => rows.map((row) => row['entryId'] as int).toList());
 
@@ -34,14 +34,20 @@ Future<List<(int, String)>> _findSenseCandidates(
   JLPTRankedWord word,
   Database db,
 ) =>
-    db
+    db.rawQuery(
-        .rawQuery('SELECT entryId, phrase '
+      'SELECT entryId, phrase '
-            'FROM ${JMdictTableNames.senseGlossary} '
+      'FROM "${JMdictTableNames.senseGlossary}" '
-            'JOIN ${JMdictTableNames.sense} USING (senseId)'
+      'JOIN "${JMdictTableNames.sense}" USING (senseId)'
-            'WHERE phrase IN (${word.meanings.map((e) => escapeStringValue(e)).join(',')})')
+      'WHERE phrase IN (${List.filled(
-        .then((rows) => rows
+        word.meanings.length,
-            .map((row) => (row['entryId'] as int, row['phrase'] as String))
+        '?',
-            .toList());
+      ).join(',')})',
+      [...word.meanings],
+    ).then(
+      (rows) => rows
+          .map((row) => (row['entryId'] as int, row['phrase'] as String))
+          .toList(),
+    );
 
 Future<int?> findEntry(
   JLPTRankedWord word,

lib/search/word_search/data_query.dart

@@ -56,14 +56,16 @@ Future<LinearWordQueryData> fetchLinearWordQueryData(
   late final List<Map<String, Object?>> senses;
   final Future<List<Map<String, Object?>>> senses_query = connection.query(
     JMdictTableNames.sense,
-    where: 'entryId IN (${entryIds.join(',')})',
+    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 (${entryIds.join(',')})',
+    where: 'entryId IN (${List.filled(entryIds.length, '?').join(',')})',
+    whereArgs: entryIds,
     orderBy: 'orderNum',
   );
 
@@ -71,21 +73,24 @@ Future<LinearWordQueryData> fetchLinearWordQueryData(
   final Future<List<Map<String, Object?>>> kanjiElements_query =
       connection.query(
     JMdictTableNames.kanjiElement,
-    where: 'entryId IN (${entryIds.join(',')})',
+    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 (${entryIds.join(',')})',
+    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 (${entryIds.join(',')})',
+    where: 'entryId IN (${List.filled(entryIds.length, '?').join(',')})',
+    whereArgs: entryIds,
   );
 
   await Future.wait([
@@ -102,7 +107,8 @@ Future<LinearWordQueryData> fetchLinearWordQueryData(
 
   late final List<Map<String, Object?>> senseAntonyms;
   final Future<List<Map<String, Object?>>> senseAntonyms_query =
-      connection.rawQuery("""
+      connection.rawQuery(
+    """
         SELECT
           "${JMdictTableNames.senseAntonyms}".senseId,
           "${JMdictTableNames.senseAntonyms}".ambiguous,
@@ -113,77 +119,89 @@ Future<LinearWordQueryData> fetchLinearWordQueryData(
         JOIN "JMdict_BaseAndFurigana"
           ON "${JMdictTableNames.senseAntonyms}"."xrefEntryId" = "JMdict_BaseAndFurigana"."entryId"
         WHERE
-          "senseId" IN (${senseIds.join(',')})
+          "senseId" IN (${List.filled(senseIds.length, '?').join(',')})
           AND COALESCE("JMdict_BaseAndFurigana"."kanjiOrderNum", 1)
               + "JMdict_BaseAndFurigana"."readingOrderNum"
               = 2
         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 (${senseIds.join(',')})',
+    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 (${senseIds.join(',')})',
+    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 (${senseIds.join(',')})',
+    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 (${senseIds.join(',')})',
+    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 (${senseIds.join(',')})',
+    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 (${senseIds.join(',')})',
+    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 (${senseIds.join(',')})',
+    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 (${senseIds.join(',')})',
+    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 (${senseIds.join(',')})',
+    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("""
+      connection.rawQuery(
+    """
         SELECT
           "${JMdictTableNames.senseSeeAlso}"."senseId",
           "${JMdictTableNames.senseSeeAlso}"."ambiguous",
@@ -194,20 +212,23 @@ Future<LinearWordQueryData> fetchLinearWordQueryData(
         JOIN "JMdict_BaseAndFurigana"
           ON "${JMdictTableNames.senseSeeAlso}"."xrefEntryId" = "JMdict_BaseAndFurigana"."entryId"
         WHERE
-          "senseId" IN (${senseIds.join(',')})
+          "senseId" IN (${List.filled(senseIds.length, '?').join(',')})
           AND COALESCE("JMdict_BaseAndFurigana"."kanjiOrderNum", 1)
               + "JMdict_BaseAndFurigana"."readingOrderNum"
               = 2
         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 (${senseIds.join(',')})',
+    where: 'senseId IN (${List.filled(senseIds.length, '?').join(',')})',
+    whereArgs: senseIds,
   );
 
   // Reading queries