From Web SQL to SQLite Wasm: the database migration guide (guida alla migrazione del database)

Con SQLite Wasm supportato dal file system privato di origine, è possibile sostituire la tecnologia dei database SQL web deprecata in modo versatile. Questo articolo fornisce una guida alla migrazione dei dati da SQL web a SQLite Wasm.

Sfondo richiesto

Il post Ritiro e rimozione di SQL web ha 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 affatto, quindi il post di follow-up SQLite Wasm nel browser supportato da Origin Private File System, delinea un insieme sostitutivo di tecnologie basate sul database SQLite, compilato in 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 quattro passaggi seguenti 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. che può servire come base per il tuo codice personalizzato in base alle tue esigenze di migrazione di SQL web.

I database SQL web di cui deve essere eseguita la migrazione

Il presupposto di base di questa guida alla migrazione è che tu abbia uno (o più) database SQL web esistenti contenenti dati pertinenti per la tua app. Nello screenshot seguente, vedi un database di esempio chiamato mydatabase con una tabella dei temporali che mappa gli umori ai livelli di gravità. Chrome DevTools ti consente di visualizzare i database SQL web per il debug, come mostrato nello screenshot seguente.

Un database SQL web controllato in DevTools di Chrome. Il database è chiamato mydatabase e ospita una tabella con tre colonne: ID riga, stato d'animo e gravità. Sono presenti tre righe di dati di esempio.

Trasformazione del database SQL web in istruzioni SQL

Per eseguire la migrazione dei dati in modo trasparente per l'utente, ovvero senza richiedere l'esecuzione di alcuna procedura di migrazione autonomamente, i dati contenuti nel database devono essere tradotti nelle istruzioni SQL originali che li hanno creati. Questa sfida si è già verificata in passato e lo script di migrazione utilizzato in questo articolo, mywebsqldump.js, si basa su una libreria 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 set 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 rimane che eseguire questi comandi SQL nel contesto di SQLite Wasm. Per tutti i dettagli relativi alla configurazione di SQLite Wasm, consulta l'articolo SQLite Wasm nel browser supportato da 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 richieste 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 il codice, controlla il file di database importato con l'estensione Chrome DevTools OPFS Explorer. Ora ci sono due file, uno con il database effettivo e uno con le informazioni di journaling. Tieni presente che questi due file risiedono nel file system privato di origine, quindi per visualizzarli devi utilizzare l'estensione OPFS Explorer.

Ispezione del file system privato di origine con gli strumenti per Chrome DevTools di Explorer OPFS. Ci sono due file, uno chiamato mydatabase.db e l'altro chiamato mydatabase.db- journal.

Per verificare effettivamente che i dati importati siano gli stessi dei dati SQL web iniziali, fai clic sul file mydatabase.db e l'estensione Explorer OPFS visualizzerà una finestra di dialogo Salva file che ti consente 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 utilizzare 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 puoi vedere nello screenshot seguente, la tabella del temporale è stata importata correttamente in SQLite.

Esplorazione del file mydatabase.db nello strumento Sqlime SQLite Playground. L'app viene mostrata con l'esecuzione del limite di 10 query SQL Query Select star from Rainstorms, che genera le tre righe dei dati di esempio iniziali provenienti da SQL web.

Liberazione dello spazio di archiviazione SQL web

Anche se è (forse sorprendentemente) impossibile eliminare un database SQL web, dovresti comunque liberare spazio di archiviazione eliminando le tabelle SQL web ormai obsolete dopo aver eseguito la migrazione dei dati in SQLite Wasm. Per elencare tutte le tabelle in un database SQL web e rilasciarle utilizzando JavaScript, utilizza il codice riportato nello snippet seguente:

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);
  }
};

Utilizzo dei dati dopo la migrazione

Dopo aver eseguito la migrazione dei dati, utilizzali come descritto in questo esempio di codice per iniziare. Per informazioni dettagliate, consulta il riferimento dell'API SQLite Wasm. Ricorda di nuovo che 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 esegue il dump dei dati SQL web sotto forma di istruzioni SQL, che vengono poi importate in SQLite Wasm supportate dal 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.

L&#39;app demo all&#39;indirizzo web-sql-to-sqlite-wasm.glitch.me.

Conclusioni

La migrazione dei tuoi database SQL web a SQLite Wasm supportata dal file system privato di origine è possibile in modo trasparente per gli utenti. Non noteranno più che i loro dati sono ora ospitati nel file system privato di origine in un database SQLite e non saranno più disponibili 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 uno sforzo iniziale, i vantaggi di una soluzione di database più solida, flessibile e, soprattutto, a prova di futuro fanno sì che l'investimento venga fatto bene.