Method delete

core/db.go:110–173

(ctx context.Context, model Model, isForAuxDB bool)

}

func (app *BaseApp) delete(ctx context.Context, model Model, isForAuxDB bool) error {
	event := new(ModelEvent)
	event.App = app
	event.Type = ModelEventTypeDelete
	event.Context = ctx
	event.Model = model

	deleteErr := app.OnModelDelete().Trigger(event, func(e *ModelEvent) error {
		pk := cast.ToString(e.Model.LastSavedPK())
		if pk == "" {
			return errors.New("the model can be deleted only if it is existing and has a non-empty primary key")
		}

		// db write
		return e.App.OnModelDeleteExecute().Trigger(event, func(e *ModelEvent) error {
			var db dbx.Builder
			if isForAuxDB {
				db = e.App.AuxNonconcurrentDB()
			} else {
				db = e.App.NonconcurrentDB()
			}

			return baseLockRetry(func(attempt int) error {
				_, err := db.Delete(e.Model.TableName(), dbx.HashExp{
					idColumn: pk,
				}).WithContext(e.Context).Execute()

				return err
			}, defaultMaxLockRetries)
		})
	})
	if deleteErr != nil {
		errEvent := &ModelErrorEvent{ModelEvent: *event, Error: deleteErr}
		errEvent.App = app // replace with the initial app in case it was changed by the hook
		hookErr := app.OnModelAfterDeleteError().Trigger(errEvent)
		if hookErr != nil {
			return errors.Join(deleteErr, hookErr)
		}

		return deleteErr
	}

	if app.txInfo != nil {
		// execute later after the transaction has completed
		app.txInfo.OnComplete(func(txErr error) error {
			if app.txInfo != nil && app.txInfo.parent != nil {
				event.App = app.txInfo.parent
			}

			if txErr != nil {
				return app.OnModelAfterDeleteError().Trigger(&ModelErrorEvent{
					ModelEvent: *event,
					Error:      txErr,
				})
			}

			return app.OnModelAfterDeleteSuccess().Trigger(event)
		})