Posso usare lo schema del ricordo con più relazioni e persistenza?

Quindi, a quanto ho capito, stai attualmente utilizzando un pattern di Memento per conservare le informazioni di pianificazione e la tua domanda riguarda il modo in cui puoi integrare questo con un database.

Bene, l'oggetto ricordo deve essere in grado di salvare e ripristinare lo stato corrente di una pianificazione. Il vero salvataggio dello stato avviene quando viene creato il ricordo, quindi la mia idea è che si debbano prendere tutti i dati come si fa già, ma poi si persistono immediatamente i dati nel database. I dati possono espandere più tabelle, ma disporre di una tabella padre per gestire un'istanza memento per registrare una relazione uno a uno. Quando si mantiene questa istanza, ottenere il proprio ID univoco che identifica quel record e consente di recuperare tutti i dati. Questo ID viene quindi inviato al ricordo. Questo significa che il memento ora contiene tutti i dati e l'ID associato ad esso nel database, giusto?

Usa il ricordo come faresti normalmente. Ha tutti i dati già presenti e dovresti essere in grado di continuare a usarli normalmente per tutto il tuo programma.

Ora, per quanto riguarda lo scenario in cui si avvia il programma ed è necessario ripristinare un particolare ricordo? Hai una tabella con tutti gli stati del tuo ricordo salvati! Prendi una lista di tutti i loro id e crea un memento contenente solo gli id per ogni record.

Quando i dati vengono richiesti per il ripristino, a questo punto, utilizzare l'id per caricare tutte le informazioni dal database. In questo modo, il tuo programma utilizza i ricordi in modo trasparente. Lo stato del ricordo è persistente nel database e tutti sono felici. :)

È possibile o meno decidere di conservare i dati persistenti con il ricordo. Con questa funzionalità, puoi anche scegliere di abbandonare i dati per mantenere solo l'id stesso (quindi se i dati sono necessari, puoi recuperarli nuovamente dal database). Se ne hai la memoria e ritieni che i dati torneranno utili, puoi scegliere di conservare semplicemente i dati per evitare di doverli caricare nuovamente dal database.

Non so quale lingua stai usando, ma alcuni linguaggi come Java supportano i soft reference che sarebbero ideali qui, che libera lo spazio in memoria solo se la memoria è richiesta. Buona fortuna!

In realtà hai due problemi:

1. Devi implementare un meccanismo di rollback
2. Devi memorizzare ogni modifica nel database

Questi richiedono due soluzioni diverse.

Se hai una tradizionale applicazione web con i POST di nuovo sul server per modificare i dati, allora il pattern di Memento non è proprio appropriato qui. Hai solo bisogno di un modo per archiviare revisioni ai record in più tabelle in un database.

Dato che stai intrattenendo il Memento Pattern, assumerò che ci sia un cliente più ricco di una semplice pagina web e un modulo.

Il Memento Pattern si prenderà cura delle modifiche allo stato dell'applicazione in memoria. La persistenza e la possibilità di ripristinare le modifiche dalla persistenza dovrebbero essere una logica separata. Quindi il tuo primo ordine del giorno è quello di implementare il Memento Pattern senza persistenza. Successivamente è necessario un modello dati che consenta la revisione dei record in un database.

Supponiamo che tu abbia un'applicazione per il blog e che tu debba salvare le revisioni su un post del blog. Avrai bisogno di due tabelle:

1. blogposts
2. BlogPostRevisions

La tabella BlogPosts sarebbe in realtà solo una chiave primaria glorificata e una chiave esterna per la tabella delle revisioni post del blog:

+------------------------+
| BlogPosts              |           +-------------------+
+------------------------+           | BlogPostRevisions |
| (PK) Id                |           +-------------------+
| (FK) CurrentRevisionId | -|------< | (PK) RevisionId   |
+------------------------+           |      Title        |
                                     |      Body         |
                                     |      PublishDate  |
                                     |      CreateDate   |
                                     +-------------------+

La creazione di un post sul blog crea 2 record su due diverse tabelle:

1. Un record nella tabella BlogPosts
2. Un record nella tabella BlogPostRevisions

Un aggiornamento al post del blog inserisce un nuovo record nella tabella BlogPostRevisions con tutti i valori correnti (e modificati di recente) per il post del blog. La colonna CurrentRevisionId nella tabella BlogPosts viene aggiornata con il nuovo ID revisione.

Il rollback di una revisione precedente è semplice come cambiare CurrentRevisionId, o semplicemente copiare una revisione esistente e inserirla come revisione più recente.

In breve, mantenere il meccanismo di annullamento della memoria in memoria (annulla) diverso dal meccanismo di rollback persistente. Il pattern Memento non affronta la persistenza e la persistenza non rende necessariamente il meccanismo di "annullamento" più intuitivo e reattivo. Hai due problemi che meritano due soluzioni diverse.