Go-Sprache und MySQL-Datenbank: Wie konvertiere ich Daten in Zeilen und Spalten?

Mit dem kontinuierlichen Wachstum des Datenvolumens sind Datenverarbeitung und -analyse zu unverzichtbaren und wichtigen Geschäftszweigen für moderne Unternehmen geworden. Die Datenbank ist das Herzstück der Datenverarbeitung und -verwaltung. Als relationale Datenbank mit hervorragender Leistung, leistungsstarken Funktionen und Benutzerfreundlichkeit wird MySQL von immer mehr Unternehmen gewählt. Die Go-Sprache ist aufgrund ihrer Vorteile wie hoher Effizienz, einfacher Entwicklung und hohem Grad an Parallelität zu einer Programmiersprache geworden, die von immer mehr Unternehmen und Entwicklern bevorzugt wird. Wie konvertiere ich Datenzeilen und -spalten in einer MySQL-Datenbank in die Go-Sprache? Dieser Artikel wird es Ihnen erklären.

1. Datentypen in der MySQL-Datenbank

Bevor wir die Verarbeitung von Datenzeilen und -spalten durchführen, müssen wir zunächst die Datentypen in der MySQL-Datenbank verstehen. MySQL unterstützt eine Vielzahl von Datentypen, einschließlich numerischer Typen, Zeichenfolgentypen, Zeit- und Datumstypen usw. Der spezifische MySQL -Datentyp und seine entsprechenden GO -Sprachtypen sind in der folgenden Tabelle angezeigt:

t64 float64 stringtime.Time[]byte

mysql Datentyp	go -Sprachtyp
Int	int
	float, real
	CHAR, VARCHAR, TEXT
	DATE, TIME, DATETIME, TIMESTAMP
	BLOB

2. Daten in MySQL speichern In der Datenbank

In der Go-Sprache können wir einen MySQL-Treiber eines Drittanbieters verwenden, um eine Verbindung zur MySQL-Datenbank herzustellen. Hier verwenden wir das Paket github.com/go-sql-driver/mysql, um eine Verbindung zur MySQL-Datenbank herzustellen.

Zuerst müssen wir die Verbindungszeichenfolge definieren, einschließlich des Datenbankbenutzernamens und -kennworts, der Server-IP-Adresse und des Server-Ports, des Datenbanknamens und anderer Informationen.

import (
    "database/sql"
    _ "github.com/go-sql-driver/mysql"
)

const (
    USERNAME = "root"
    PASSWORD = "12345678"
    NETWORK  = "tcp"
    SERVER   = "localhost"
    PORT     = 3306
    DATABASE = "test"
)

func Connect() (*sql.DB, error) {
    connStr := fmt.Sprintf("%s:%s@%s(%s:%d)/%s", USERNAME, PASSWORD, NETWORK, SERVER, PORT, DATABASE)
    db, err := sql.Open("mysql", connStr)
    if err != nil {
        return nil, err
    }
    return db, nil
}

Wir haben die Connect-Funktion definiert, um eine Verbindung zur MySQL-Datenbank herzustellen und ein Objekt vom Typ sql.DB zurückzugeben. Als Nächstes können wir eine Struktur in der Go-Sprache definieren, um die Daten darzustellen, die wir speichern möchten. Am Beispiel der Schülerinformationen ist die Struktur wie folgt definiert:

type student struct {
    id   int
    name string
    age  int
}

Als Nächstes können wir über den folgenden Code eine Schülerinformation in die MySQL-Datenbank einfügen:

func InsertStudent(db *sql.DB, stu *student) error {
    sql := "INSERT INTO student (name, age) VALUES (?, ?)"
    stmt, err := db.Prepare(sql)
    if err != nil {
        return err
    }
    defer stmt.Close()
    _, err = stmt.Exec(stu.name, stu.age)
    if err != nil {
        return err
    }
    return nil
}

Der obige Code definiert eine InsertStudent-Funktion zum Einfügen eines Schülers Objekt in die MySQL-Datenbank in der Student-Tabelle. Im Vorfeld definieren wir die Schülertabelle in der Datenbank als (Name VARCHAR(50), Alter INT).

3. Fragen Sie die Daten in der MySQL-Datenbank ab

In der Go-Sprache können wir Abfragen verwenden, um SQL-Anweisungen auszuführen. Im Folgenden erfahren Sie, wie Sie Schülerinformationen in der Schülertabelle abfragen:

func QueryStudent(db *sql.DB) ([]*student, error) {
    students := make([]*student, 0)
    rows, err := db.Query("SELECT * FROM student")
    if err != nil {
        return nil, err
    }
    defer rows.Close()
    for rows.Next() {
        stu := new(student)
        err := rows.Scan(&stu.id, &stu.name, &stu.age)
        if err != nil {
            return nil, err
        }
        students = append(students, stu)
    }
    if err = rows.Err(); err != nil {
        return nil, err
    }
    return students, nil
}

Der obige Code definiert eine QueryStudent-Funktion, um alle Schülerinformationen in der Schülertabelle in der MySQL-Datenbank abzufragen. Die Funktion gibt ein Array mit Schülerinformationen zurück.

4. Datenzeilen in Datenspalten konvertieren

Manchmal müssen wir Datenzeilen in Datenspalten konvertieren. Beispielsweise müssen wir in jeder Zeile der Schülerinformationstabelle 4 Schülerinformationen anzeigen. Im Folgenden erfahren Sie, wie Sie ein Array mit Schülerinformationen in ein zweidimensionales Array mit Schülerinformationen umwandeln:

func ToColumnArray(students []*student, n int) [][]*student {
    result := make([][]*student, (len(students)+n-1)/n)
    for i := range result {
        result[i] = make([]*student, n)
    }
    for i, s := range students {
        row, col := i/n, i%n
        result[row][col] = s
    }
    return result
}

Der obige Code definiert eine ToColumnArray-Funktion, um ein Array mit Schülerinformationen in ein zweidimensionales Array mit Schülerinformationen umzuwandeln Zeile mit n Schülerinformationen.

5. Datenspalten in Datenzeilen umwandeln

Andererseits müssen wir auch Datenspalten in Datenzeilen umwandeln. Beispielsweise müssen wir eine große Tabelle in mehrere kleine Tabellen aufteilen. Im Folgenden erfahren Sie, wie Sie ein zweidimensionales Array mit Schülerinformationen in ein Array mit Schülerinformationen umwandeln:

func ToRowArray(students [][]*student) []*student {
    result := make([]*student, 0)
    for _, row := range students {
        for _, s := range row {
            if s != nil {
                result = append(result, s)
            }
        }
    }
    return result
}

Der obige Code definiert eine ToRowArray-Funktion, um ein zweidimensionales Array mit Schülerinformationen in ein Array mit Schülerinformationen umzuwandeln.

Zusammenfassung

🎜In diesem Artikel wird erläutert, wie Sie eine Verbindung zur MySQL-Datenbank in der Go-Sprache herstellen und die Konvertierungsverarbeitung für Datenzeilen und -spalten durchführen. In der Praxis sind Datenverarbeitung und -verwaltung von entscheidender Bedeutung. Ich hoffe, dieser Artikel kann Sie inspirieren und Ihnen dabei helfen, große Datenmengen besser zu verarbeiten und zu verwalten. 🎜

Das obige ist der detaillierte Inhalt vonGo-Sprache und MySQL-Datenbank: Wie konvertiere ich Daten in Zeilen und Spalten?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!