insertManyInputs method

Future<List<T>> insertManyInputs(List<Object> inputs, { bool ignoreConflicts = false, bool returning = true, bool fallbackToOriginalWhenNoReturn = true, })

Inserts flexible inputs and returns hydrated models.

Implementation

Future<List<T>> insertManyInputs(
  List<Object> inputs, {
  bool ignoreConflicts = false,
  bool returning = true,
  bool fallbackToOriginalWhenNoReturn = true,
}) async {
  final build = _buildInsertRows(inputs);
  if (build.rows.isEmpty) return const [];

  final entries = _zipInsertEntries(inputs, build);
  final ready = <_InsertEntry<T>>[];

  for (final entry in entries) {
    if (!_emitSavingEvent(entry.model, entry.inputMap)) continue;

    if (!_suppressEvents) {
      final creatingEvent = ModelCreatingEvent(
        modelType: definition.modelType,
        tableName: definition.tableName,
        attributes: Map<String, dynamic>.from(entry.inputMap),
      );
      _events.emit(creatingEvent);
      if (creatingEvent.isCancelled) continue;
    }
    ready.add(entry);
  }

  if (ready.isEmpty) return const [];

  final mutation = MutationPlan.insert(
    definition: definition,
    rows: ready.map((entry) => entry.row).toList(growable: false),
    driverName: context.driver.metadata.name,
    returning: returning,
    ignoreConflicts: ignoreConflicts,
  );

  final result = await context.runMutation(mutation);
  if (ignoreConflicts && result.affectedRows == 0) {
    return const [];
  }

  final originalModels = ready
      .map((entry) => entry.model)
      .whereType<T>()
      .toList(growable: false);
  final inputMaps = ready
      .map((entry) => entry.inputMap)
      .toList(growable: false);

  final models = _hydrateMutationResults(
    result,
    originalModels: originalModels,
    inputMaps: inputMaps,
    canCreateFromInputs: !ignoreConflicts,
    fallbackToOriginalWhenNoReturn: fallbackToOriginalWhenNoReturn,
  );

  _emitCreatedEvents(models, inputMaps);
  _emitSavedEvents(models, inputMaps);
  return models;
}