Using multiple listening streams, triggered multiple times

[disonwei]

  static Stream<List<HabitCheck>> watchAllHabitCheckByHabitIdWithYear(
      int habitId, int year) {

    print("habitId ${habitId}");
    print("year ${year}");

    final query = db.select(db.habitChecksTable)
      ..where((habit) =>
          habit.habitId.equals(habitId) &
          habit.targetDate
              .modify(const DateTimeModifier.localTime())
              .year
              .equals(year));

    return query.watch();
  }

The above is one of my query related methods.

  listeningHabit() {
    habitChecksSubscription =
    HabitChecksDao.watchAllHabitCheckByHabitIdWithYear(
            habit.value.id!, DateTime.now().year)
        .listen((List<HabitCheck> habitChecks) {
      this.habitChecks.value = habitChecks;

      print("habitChecks ${habitChecks.length}");
    });
  }

I called listeningHabit() at different locations in the code 4 times, and each time the habit.value.id! is different, for example, they are 1, 2, 3, and 4 respectively.

So when I update or insert data into the database, suppose there is a data id 3 habitId 2. Then when this data is inserted into the database. Will all 4 streams trigger or only the habit.value.id! Is that stream trigger for 2?

[disonwei]

The above is an abstract of the issue I encountered. The problem I faced is as follows:

I am using GetX. I loop through a list and create different controllers based on habit.id.

  Widget habitList(context) {
    return ListView.builder(
      padding: const EdgeInsets.only(top: 0),
      physics: const NeverScrollableScrollPhysics(),
      shrinkWrap: true,
      itemCount: controller.habitDataController.habits.length,
      itemBuilder: (context, index) {
        Habit habit = controller.habitDataController.habits[index];

        final habitController =
            Get.isRegistered<HabitItemController>(tag: habit.id.toString())
                ? Get.find<HabitItemController>(tag: habit.id.toString())
                : Get.put(HabitItemController(habit),
                    tag: habit.id.toString(), permanent: true);

        return GestureDetector(
          onTap: () {
            controller.homeController.onClickHabit(habit);
          },
          child: HabitItemView(
            habitController: habitController,
          ),
        );
      },
    );
  }

In each controller, I called the listeningHabit() method as mentioned above.

Assuming I have now created 4 controllers, there are now 4 watchAllHabitCheckByHabitIdWithYear instances, and their query conditions habitId are different.

  static recordHabitCheck(int habitId,
      {required DateTime targetDate,
      required DateTime dateTime,
      completionPerDay = 1}) async {
    return db.transaction(() async {
      final existingCheck = await (db.select(db.habitChecksTable)
            ..where((check) => check.habitId.equals(habitId))
            ..where((check) => check.targetDate.equals(targetDate)))
          .getSingleOrNull();

      logUtil("existingCheck ${existingCheck?.toJson()}");

      if (existingCheck == null) {

        await db
            .into(db.habitChecksTable)
            .insert(HabitChecksTableCompanion.insert(
              habitId: Value(habitId),
              numberOfCompleted: const Value(1),
              completionPerDay: Value(completionPerDay),
              completionTime: completionPerDay == 1
                  ? Value(dateTime)
                  : const Value.absent(),
              updateAt: DateTime.now(),
              targetDate: Value(targetDate),
            ));
      } else {
        if (existingCheck.numberOfCompleted < existingCheck.completionPerDay) {
          int currentNumberOfCompleted = existingCheck.numberOfCompleted + 1;

          await (db.update(db.habitChecksTable)
                ..where(
                    (habitCheck) => habitCheck.id.equals(existingCheck.id!)))
              .write(
            HabitChecksTableCompanion(
              id: Value(existingCheck.id),
              numberOfCompleted: Value(currentNumberOfCompleted),
              updateAt: Value(DateTime.now()), // 更新修改时间
              completionTime:
                  currentNumberOfCompleted == existingCheck.completionPerDay
                      ? Value(dateTime)
                      : const Value.absent(),
            ),
          );
        } else {
          await (db.update(db.habitChecksTable)
                ..where(
                    (habitCheck) => habitCheck.id.equals(existingCheck.id!)))
              .write(
            HabitChecksTableCompanion(
              id: Value(existingCheck.id),
              numberOfCompleted: Value(0),
              updateAt: Value(DateTime.now()), // 更新修改时间
              completionTime: Value<DateTime?>(null),
            ),
          );
        }
      }
    });
  }

Now when I call the above method to add or update data, I find that all four existing streams are triggered.
In theory, I want to update or add habitId corresponding to the flow trigger, other flows do not trigger.

[simolus3]

So when I update or insert data into the database, suppose there is a data id 3 habitId 2. Then when this data is inserted into the database. Will all 4 streams trigger or only the habit.value.id! Is that stream trigger for 2?

All four streams will trigger - you'd have to use distinct() with a ListEquality filter on them to avoid duplicate notifications.
Query streams are implemented with a table-level granularity only - essentially, we never want to miss a notification, even if that means refreshing some streams more often than necessary.

[disonwei]

Thank you for your reply. I still don't quite understand how to implement it. Can you give me an example?

I will describe my problem again：

static Stream<Habit> watchHabitByHabitId(int habitId) {
return (db.select(db.habitsTable)..where((tbl) => tbl.id.equals(habitId)))
.watchSingle();

Suppose I create multiple listeners

1. HabitDao.watchHabitByHabitId(1).listen((Habit habit) {...});
2. HabitDao.watchHabitByHabitId(2).listen((Habit habit) {...});
3. HabitDao.watchHabitByHabitId(3).listen((Habit habit) {...});

class Habit{
 int id;
}
habit1=Habit(1);
habit2=Habit(2);
habit3=Habit(3);

I want only the first listener to trigger when I modify, add or delete the data with id 1 in the data.
And the current situation is that all three will be triggered.

Can you give me an example to achieve my needs? Thank you very much!

[simolus3]

Ah in that case since Habit implements operator == you can just do

return (db.select(db.habitsTable)..where((tbl) => tbl.id.equals(habitId)))
.watchSingle().distinct();