Implementierung der Knotenverbindung zur MySQL-Abfragetransaktionsverarbeitung

D:\nodejs_mysql>npm init -y # Schnelles Erstellen von Paketverwaltungsdateien

D:\nodejs_mysql>npm i mysql -D # MySQL-Abhängigkeitspaket installieren

const mysql = erfordern("mysql");

// Einen MySQL-Verbindungspool erstellen const pool = mysql.createPool({
  Host: "127.0.0.1", // Die Adresse 127.0.0.1 für die Verbindung zur Datenbank ist die lokale MySQL
  Benutzer: „root“, // Benutzername für die Verbindung mit der Datenbank. Root hat die höchste Autorität. Passwort: „“, // Passwort für die Verbindung mit der Datenbank. Datenbank: „apm“, // Datenbankname für den Vorgang. Port: „3306“, // Portnummer für die Verbindung mit MySQL. multipleStatements: true, // Dieses Element kann ignoriert werden, wenn Sie mehrere SQL-Anweisungen gleichzeitig ausführen möchten. });

Funktion select() {
  // Anfrage zur Verbindung mit MySQL
  pool.getConnection((err, Verbindung) => {
    //Bei fehlgeschlagener Verbindung einen Fehler melden if (err) throw err;
    // Holen Sie sich ein Verbindungsobjekt und rufen Sie die Abfragemethode auf, um die SQL-Anweisung auszuführen. let sql = "select * from goods";
    //Führen Sie die SQL-Anweisungsabfrage aus. Der zweite Parameter ist der von der SQL-Anweisung benötigte Parameter. Sie können ihn leer lassen. connection.query(sql, (errors, results, fields) => {
      // Verbindung freigeben connection.release();
      // Wenn beim Ausführen der SQL-Anweisung ein Fehler auftritt, werfen Sie einen Fehler, wenn (Fehler) Fehler werfen;
      console.log(Ergebnisse);
      konsole.log(Felder);
    });
  });
}

wählen();

// index.js
// ... Ignorieren Sie den vorherigen Code, um einen MySQL-Verbindungspool zu erstellen. Funktion query(sql, params) {
  returniere neues Promise((lösen, ablehnen) => {
    pool.getConnection((err, Verbindung) => {
      //Bei fehlgeschlagener Verbindung einen Fehler melden if (err) return reject(err);
      // Holen Sie sich ein Verbindungsobjekt und rufen Sie die Abfragemethode auf, um die SQL-Anweisung auszuführen. // Führen Sie die SQL-Anweisungsabfrage aus. Der zweite Parameter ist der von der SQL-Anweisung benötigte Parameter. Dieser kann weggelassen werden. connection.query(sql, params, (errors, results, fields) => {
        // Verbindung freigeben connection.release();
        // Wenn beim Ausführen der SQL-Anweisung ein Fehler auftritt, wird ein Fehler ausgegeben, if (Fehler) return reject(Fehler);
        Lösung (Ergebnisse);
      });
    });
  });
}

Abfrage("Wählen Sie * aus Waren aus", null).dann((Ergebnis) => {
  console.log(Ergebnis);
});
modul.exporte = {
  Abfrage,
};

// Daten.js
const index = erfordern("./index.js");
var sql = "Wählen Sie * aus Waren aus";
Index
  .query(sql, null)
  .then((Ergebnis) => {
    // irgendetwas tun …
  })
  .catch((err) => {
    // Fehler
    console.log(fehler);
  });

// index.js

// .... Teil des Codes zum Erstellen eines Pools /**
 * MySQL-Transaktionsverarbeitung * @param {Array} SQLS-SQL-Anweisung, die ausgeführt werden soll * @param {Array} Parameter, die den Parametern der obigen SQL-Anweisung entsprechen * @returns {Promise} gibt ein Promise zurück
 */
Funktion Transaktion (SQL, Parameter) {
  returniere neues Promise((lösen, ablehnen) => {
    pool.getConnection(Funktion (err, Verbindung) {
      // Verbindung fehlgeschlagen Promise gibt Fehler direkt zurück if (err) {
        Rückgabe ablehnen (Fehler);
      }
      // Wenn Anweisung und Parameternummer nicht übereinstimmen, gibt Promise direkt einen Fehler zurück, if (sqls.length !== params.length) {
        connection.release(); // Freigeben return reject(new Error("Die Anweisung stimmt nicht mit dem übergebenen Wert überein"));
      }
      // Ausführung der Transaktion starten connection.beginTransaction((beginErr) => {
        // Transaktion konnte nicht erstellt werden if (beginErr) {
          Verbindung.Freigabe();
          Rückgabe ablehnen (BeginErr);
        }
        console.log("Starten Sie die Ausführung von Transaktionen, insgesamt " + sqls.length + " Anweisungen");
        //Gibt ein Promise-Array zurück let funcAry = sqls.map((sql, index) => {
          gib ein neues Promise zurück((sqlResolve, sqlReject) => {
            const Daten = Parameter[Index];
            Verbindung.Abfrage(sql, Daten, (sqlErr, Ergebnis) => {
              wenn (sqlErr) {
                gibt sqlResolve(sqlErr) zurück;
              }
              sqlReject(Ergebnis);
            });
          });
        });
        //Verwende die Methode „all“, um den Status jedes darin enthaltenen Promise zu überprüfen. Promise.all(funcAry)
          .then((arrResult) => {
            // Wenn jede SQL-Anweisung erfolgreich ausgeführt wurde, kommt es zu diesem Punkt. Hier muss die Transaktion festgeschrieben werden, damit die vorherige SQL-Ausführung wirksam wird. // Die Transaktion festschreiben connection.commit(function (commitErr, info) {
              wenn (commitErr) {
                // Übermittlung der Transaktion fehlgeschlagen console.log("Übermittlung der Transaktion fehlgeschlagen: " + commitErr);
                // Transaktions-Rollback, zuvor ausgeführte SQL-Anweisungen sind ungültig connection.rollback(function (err) {
                  if (err) console.log("Rollback fehlgeschlagen: " + err);
                  Verbindung.Freigabe();
                });
                // Status des fehlgeschlagenen Versprechens zurückgeben return reject(commitErr);
              }

              Verbindung.Freigabe();
              // Die Transaktion gibt das Ergebnis jeder SQL-Ausführung erfolgreich als Array-Struktur zurück: resolve(arrResult);
            });
          })
          .catch((Fehler) => {
            // Wenn eine der mehreren SQL-Anweisungen während der Ausführung einen Fehler meldet, führen Sie direkt ein Rollback durch connection.rollback(function () {
              console.log("SQL-Ausführung fehlgeschlagen: " + Fehler);
              Verbindung.Freigabe();
              ablehnen(Fehler);
            });
          });
      });
    });
  });
}
modul.exporte = {
  Transaktion,
};

// Daten.js
const index = erfordern("./index.js");
var sqls = [
  „Löschen von Waren, wobei Waren-ID = ?“, // Löschanweisung „Warensatz aktualisieren, Num = ?, wobei Waren-ID = ?;“, // Aktualisierungsanweisung];
var Parameter = [
  [1], // parmas liegt im Array-Format vor und entspricht der SQL-Anweisung in SQLs? [5, 3],
];

Index
  .transaction(sqls, Parameter)
  .then((arrResult) => {
    // irgendetwas tun …
  })
  .catch((err) => {
    // Fehler
    console.log(fehler);
  });