Con SQLite Wasm supportato dal file system privato di origine, è disponibile una sostituzione versatile per la tecnologia di database SQL web deprecata. Questo articolo è una guida alla migrazione dei dati da SQL web a SQLite Wasm.
Sfondo obbligatorio
Nel post relativo al ritiro e rimozione di SQL Web è stato annunciato il ritiro della tecnologia di database SQL web. Anche se la tecnologia stessa potrebbe essere deprecata, i casi d'uso affrontati dalla tecnologia non lo sono di gran lunga, quindi il post di follow-up SQLite Wasm nel browser supportato dall'Origin Private File System, descrive un set sostitutivo di tecnologie basate sul database SQLite, compilato su Web Assembly (Wasm) e supportato dal file system privato dell'origine. Per chiudere il cerchio, questo articolo mostra come eseguire la migrazione dei database da SQL web a SQLite Wasm.
Migrazione dei database
I seguenti quattro passaggi dimostrano l'idea concettuale della migrazione di un database SQL web a SQLite Wasm, con il database SQLite supportato dal file system privato di origine. Queste informazioni possono fungere da base per il tuo codice personalizzato in base alle tue esigenze di migrazione di SQL web.
I database SQL web di cui eseguire la migrazione
Il presupposto di base di questa guida alla migrazione è che tu disponga di uno o più database SQL web esistenti con dati pertinenti alla tua app. Nello screenshot di seguito, vedi un database di esempio chiamato mydatabase con una tabella dei temporali che mappa gli umori alle gravità. Chrome DevTools consente di visualizzare i database SQL web per il debug, come mostrato nello screenshot seguente.
Traduzione del database SQL web in istruzioni SQL
Per eseguire la migrazione dei dati in modo trasparente per l'utente, ovvero senza dover eseguire in autonomia i passaggi di migrazione, i dati del database devono essere riconvertiti nelle istruzioni SQL originali che li hanno creati inizialmente. Questa sfida esiste in passato e lo script di migrazione utilizzato in questo articolo, mywebsqldump.js, si basa su una raccolta della community chiamata websqldump.js, con alcune piccole modifiche. Il seguente esempio di codice mostra il codice necessario per tradurre il database SQL web mydatabase in un insieme di istruzioni SQL.
websqldump.export({
database: 'mydatabase',
version: '1.0',
success: function(sql) {
// The SQL statements.
},
error: function(err) {
// Handle the error.
}
});
L'esecuzione di questo codice genera la stringa delle istruzioni SQL riportata di seguito.
CREATE TABLE IF NOT EXISTS rainstorms (mood text, severity int);
INSERT INTO rainstorms(mood,severity) VALUES ('somber','6');
INSERT INTO rainstorms(mood,severity) VALUES ('rainy','8');
INSERT INTO rainstorms(mood,severity) VALUES ('stormy','2');
Importazione dei dati in SQLite Wasm
Non ti resta che eseguire questi comandi SQL nel contesto di SQLite Wasm. Per tutti i dettagli relativi alla configurazione di SQLite Wasm, ti rimando all'articolo SQLite Wasm nel browser supportato dall'Origin Private File System, ma il concetto è riportato di seguito. Ricorda che questo codice deve essere eseguito in un worker (che la libreria crea automaticamente per te), con le intestazioni HTTP obbligatorie impostate correttamente. Puoi installare il pacchetto @sqlite.org/sqlite-wasm da npm.
import { sqlite3Worker1Promiser } from '@sqlite.org/sqlite-wasm';
(async () => {
try {
const promiser = await new Promise((resolve) => {
const _promiser = sqlite3Worker1Promiser({
onready: () => {
resolve(_promiser);
},
});
});
let response;
response = await promiser('open', {
filename: 'file:mydatabase.db?vfs=opfs',
});
const { dbId } = response;
const sql = `
CREATE TABLE IF NOT EXISTS rainstorms (mood text, severity int);
INSERT INTO rainstorms(mood,severity) VALUES ('somber','6');
INSERT INTO rainstorms(mood,severity) VALUES ('rainy','8');
INSERT INTO rainstorms(mood,severity) VALUES ('stormy','2');`
await promiser('exec', { dbId, sql });
await promiser('close', { dbId });
} catch (err) {
if (!(err instanceof Error)) {
err = new Error(err.result.message);
}
console.error(err.name, err.message);
}
})();
Dopo aver eseguito questo codice, controlla il file di database importato con l'estensione di Chrome DevTools OPFS Explorer. Ora ci sono due file, uno con il database effettivo e uno con le informazioni per l'inserimento nel journal. Tieni presente che questi due file risiedono nel file system privato di origine, quindi devi utilizzare l'estensione OPFS Explorer per visualizzarli.
Per verificare che i dati importati corrispondano ai dati SQL web iniziali, fai clic sul file mydatabase.db e l'estensione OPFS Explorer visualizzerà la finestra di dialogo Salva file per consentirti di salvare il file nel file system visibile all'utente. Dopo aver salvato il file di database, utilizza un'app di visualizzazione SQLite per esplorare i dati. La presentazione delle API di Project Fugu include diverse app per lavorare con SQLite nel browser. Ad esempio, Sqlime — SQLite Playground consente di aprire un file di database SQLite dal disco rigido ed eseguire query sul database. Come vedi nello screenshot di seguito, la tabella degli temporali è stata importata correttamente in SQLite.
Liberare spazio di archiviazione per SQL web
Anche se (forse sorprendentemente) è impossibile eliminare un database SQL web, devi comunque liberare spazio eliminando le tabelle SQL web ora obsolete dopo aver eseguito la migrazione dei dati in SQLite Wasm. Per elencare tutte le tabelle di un database SQL web e rilasciarle utilizzando JavaScript, utilizza il codice riportato nel seguente snippet:
const dropAllTables = () => {
try {
db.transaction(function (tx) {
tx.executeSql(
"SELECT name FROM sqlite_master WHERE type='table' AND name !='__WebKitDatabaseInfoTable__'",
[],
function (tx, result) {
const len = result.rows.length;
const tableNames = [];
for (let i = 0; i < len; i++) {
const tableName = result.rows.item(i).name;
tableNames.push(`'${tableName}'`);
db.transaction(function (tx) {
tx.executeSql('DROP TABLE ' + tableName);
});
}
console.log(`Dropped table${tableNames.length > 1 ? 's' : ''}: ${tableNames.join(', ')}.`);
}
);
});
} catch (err) {
console.error(err.name, err.message);
}
};
Lavorare con i dati dopo la migrazione
Dopo aver eseguito la migrazione dei dati, utilizzali come descritto in questo esempio di codice per iniziare. Per maggiori dettagli, consulta il riferimento dell'API SQLite Wasm. Promemoria: devi accedere a SQLite Wasm da un worker se utilizzi il file system privato di origine come backend di archiviazione.
Provalo
Questa demo ti consente di completare un database SQL web con dati di esempio, quindi di eseguire il dump dei dati SQL web come istruzioni SQL, che successivamente vengono importate in SQLite Wasm con il supporto del file system privato di origine. Infine, libera spazio di archiviazione eliminando i dati SQL web obsoleti. Controlla il codice sorgente per l'implementazione completa, incluso il file mywebsqldump.js con patch.
Conclusioni
La migrazione dei tuoi database SQL web a SQLite Wasm supportato dal file system privato di origine è possibile in modo trasparente per i tuoi utenti. Non noteranno che i loro dati sono ora ospitati nel file system privato di origine in un database SQLite e non sono più presenti in SQL web. Nel complesso, la migrazione da SQL web a SQLite è un passaggio necessario per gli sviluppatori web che vogliono garantire la stabilità e la scalabilità a lungo termine delle loro applicazioni. Sebbene il processo possa richiedere alcuni sforzi iniziali, i vantaggi di una soluzione di database più solida, flessibile e, soprattutto, a prova di futuro, rendono l'investimento davvero vantaggioso.