Verwenden Sie MySQL in der Go-Sprache, um eine nicht relationale Datenverarbeitung zu implementieren

Mit der rasanten Entwicklung des Internets werden nicht-relationale Datenbanken (NoSQL) immer häufiger verwendet, und in der Go-Sprache gibt es auch einige nicht-relationale Möglichkeiten zur Datenverarbeitung. Für einige herkömmliche relationale Datenbanken wie MySQL können wir jedoch auch einige Techniken verwenden, um nicht relationale Datenverarbeitungsfunktionen zu implementieren.

In diesem Artikel werden die Methoden und Techniken zur Verwendung von MySQL zur Implementierung der nicht-relationalen Datenverarbeitung in der Go-Sprache vorgestellt, einschließlich der Erstellung und Gestaltung einer nicht-relationalen Tabelle, und anhand von Beispielen demonstriert, wie man liest, schreibt und erneuert. In diesem Prozess verwenden wir eine dieser Bibliotheken: github.com/go-sql-driver/mysql.

1. Erstellen Sie nicht relationale Tabellen.

MySQL-Datenbanken betrachten wir normalerweise als relationale Datenbank. Daher müssen wir die Tabellen entwerfen und die Beziehung zwischen den Tabellen aufrechterhalten. Manchmal müssen wir Daten jedoch in einer nicht relationalen Struktur speichern, beispielsweise im JSON-Format.

In MySQL können wir Felder vom Typ JSON verwenden, um nicht relationalen Speicher zu implementieren. Zum Beispiel erstellen wir eine Tabelle zum Speichern von Benutzerinformationen, die ein JSON-Typfeld „info“ zum Speichern der persönlichen Informationen des Benutzers enthält:

CREATE TABLE users (
   id INT(11) NOT NULL AUTO_INCREMENT,
   name VARCHAR(50) NOT NULL,
   info JSON NOT NULL,
   PRIMARY KEY (id)
);

Im obigen Code erstellen wir eine Tabelle mit dem Namen „Benutzer“. Sie enthält drei Felder: ID, Name und Informationen. Der Typ des Infofelds ist JSON, das zur Speicherung der persönlichen Daten des Benutzers verwendet wird. In praktischen Anwendungen können wir auch andere nicht relationale Typen wie BLOB, TEXT usw. verwenden.

2. Verwenden Sie die Go-Sprache, um eine Verbindung zur MySQL-Datenbank herzustellen.

Die Verbindung zur MySQL-Datenbank in der Go-Sprache erfordert die Verwendung einer Drittanbieter-Bibliothek. Die am häufigsten verwendete davon ist github.com/go-sql-driver/mysql. Zuerst müssen Sie diese Bibliothek installieren, die mit dem folgenden Befehl installiert werden kann:

go get github.com/go-sql-driver/mysql

Diese Bibliothek stellt einen sql.DB-Typ bereit, der für Datenbankverbindungen und -operationen verwendet werden kann. Bevor wir eine Verbindung zur Datenbank herstellen, müssen wir einige Konfigurationsinformationen wie folgt bereitstellen:

dsn := "root:password@(127.0.0.1:3306)/database_name?charset=utf8mb4&parseTime=True&loc=Local"
db, err := sql.Open("mysql", dsn)
if err != nil {
   panic(err)
}
defer db.Close()

dsn ist ein Datenquellenname, der zum Herstellen einer Verbindung zur Datenbank verwendet wird. Dazu gehören Benutzername, Passwort, Hostadresse, Portnummer, Datenbankname, Verschlüsselungsmethode und andere Informationen. Im obigen Code verwenden wir die lokale Hostadresse und die Standardportnummer 3306 und ersetzen Benutzername und Passwort durch die entsprechenden Werte. Wenn die Verbindung erfolgreich ist, enthält die Datenbankvariable einen Verweis auf die MySQL-Datenbank, mit der Sie eine Verbindung hergestellt haben.

3. Gehen Sie zur Sprache, um nicht relationale Daten zu lesen und zu schreiben.

Nachdem wir eine Verbindung zur MySQL-Datenbank hergestellt haben, können wir den Typ sql.DB verwenden, um SQL-Abfragen auszuführen und zugehörige Daten abzurufen. Für nicht relationale Daten können wir die JSON-Funktion von MySQL verwenden, um Felder vom Typ JSON zu lesen und zu schreiben.

1. Nicht relationale Daten schreiben

Der folgende Code zeigt, wie neue Benutzerinformationen in die Benutzertabelle geschrieben werden:

info := `{
   "age": 23,
   "gender": "male",
   "email": "john@example.com"
}`
result, err := db.Exec("INSERT INTO users(name, info) VALUES(?, ?)", "John", info)
if err != nil {
   panic(err)
}
fmt.Printf("New user id: %d
", result.LastInsertId())

In diesem Beispiel definieren wir zunächst ein JSON-Zeichen, das eine Benutzerinformationszeichenfolge enthält. Anschließend verwenden wir die Exec-Funktion, um die Einfügeanweisung auszuführen und die Benutzerinformationen als Parameter an die SQL-Anweisung zu übergeben. Nachdem das Einfügen erfolgreich war, erhalten wir die ID des neuen Benutzers und geben sie aus.

2. Lesen nicht-relationaler Daten

Als nächstes zeigen wir, wie man JSON-Daten liest, die in nicht-relationalen Feldern gespeichert sind. Verwenden Sie die JSON_EXTRACT-Funktion von MySQL, um einfach ein Schlüssel-Wert-Paar in JSON zu erhalten. Der folgende Code zeigt, wie alle Benutzerinformationen in der Benutzertabelle gelesen werden:

rows, err := db.Query("SELECT * FROM users")
if err != nil {
   panic(err)
}
defer rows.Close()

for rows.Next() {
   var id int
   var name string
   var info []byte
   err := rows.Scan(&id, &name, &info)
   if err != nil {
      panic(err)
   }
   var user map[string]interface{}
   err = json.Unmarshal(info, &user)
   if err != nil {
      panic(err)
   }
   fmt.Printf("ID: %d, Name: %s, Age: %f, Gender: %s, Email: %s
", id, name, user["age"], user["gender"], user["email"])
}

In diesem Beispiel verwenden wir zunächst die Funktion db.Query, um alle Daten in der Benutzertabelle abzufragen. Anschließend verwenden wir die Funktion rows.Scan, um die ID-, Namens- und Infofelder jeder Datenzeile zu lesen. Als nächstes konvertieren wir den Wert des Infofelds in eine Benutzervariable vom Typ „map[string]interface{}“ und verwenden zum Parsen die Funktion „json.Unmarshal“. Schließlich geben wir die ID, den Namen, das Alter, das Geschlecht und die E-Mail-Adresse jedes Benutzers aus.

3. Aktualisierung nicht-relationaler Daten

Abschließend zeigen wir, wie man in nicht-relationalen Feldern gespeicherte Daten aktualisiert. Mit der JSON_SET-Funktion von MySQL kann ein Schlüssel-Wert-Paar in einem JSON-Feld dynamisch aktualisiert werden. Der folgende Code zeigt, wie die E-Mail-Adresse des Benutzers auf einen neuen Wert aktualisiert wird:

result, err := db.Exec("UPDATE users SET info=JSON_SET(info, '$.email', ?) WHERE name=?", "john_doe@example.com", "John")
if err != nil {
   panic(err)
}
rowsAffected, err := result.RowsAffected()
if err != nil {
   panic(err)
}
fmt.Printf("Rows affected: %d
", rowsAffected)

In diesem Beispiel verwenden wir die Exec-Funktion, um die Update-Anweisung auszuführen und die neue E-Mail-Adresse als Parameter an die JSON_SET-Funktion in der SQL-Anweisung zu übergeben . Wir verwenden die WHERE-Klausel, um den Namen des zu aktualisierenden Benutzers anzugeben. Nach erfolgreichem Update prüfen wir die Anzahl der betroffenen Zeilen und geben diese aus.

4. Zusammenfassung

In der Go-Sprache können wir eine MySQL-Datenbank verwenden, um nicht relationale Daten zu speichern. Durch die Verwendung von Feldern vom Typ JSON können wir Daten problemlos im JSON-Format speichern und verarbeiten. In diesem Artikel werden Methoden und Techniken zum Erstellen nicht relationaler Tabellen, zum Herstellen einer Verbindung zu MySQL-Datenbanken, zum Lesen und Schreiben nicht relationaler Daten sowie Beispiele für die Verwendung der Funktionen JSON_EXTRACT und JSON_SET für Datenoperationen vorgestellt. Sie können Ihnen dabei helfen, MySQL besser zur Verarbeitung nicht relationaler Daten in praktischen Anwendungen zu nutzen.

Das obige ist der detaillierte Inhalt vonVerwenden Sie MySQL in der Go-Sprache, um eine nicht relationale Datenverarbeitung zu implementieren. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!