Lernen Sie die Go-Sprache, um die MySQL-Vorverarbeitung durchzuführen

                                                                                                                                                                              

Freundliche Erinnerung: Das Lesen dieses Artikels dauert etwa 6 Minuten und 41 Sekunden. Vielen Dank für das Lesen. Diese Website abonnieren

Vorverarbeitung

Vorverarbeitung ist eine von MySQL verwendete Technologie, um häufige Anfragen von Clients zu verhindern Dieselbe Anweisung ist in MySQL vorinstalliert, die Betriebsvariablendaten werden durch Platzhalter ersetzt, wodurch häufige Anfragen an MySQL reduziert werden und der Server effizient läuft.

Hier ist der Client nicht die C/S-Architektur zwischen Front- und Backend, sondern die C/S-Architektur, in der das Hintergrundprogramm den Datenbankserver betreibt. Auf diese Weise können Sie das Hintergrundprogramm kurz verstehen Der Client fordert den MySQL-Server an und verarbeitet die Ergebnisse.

Verwandte Lernempfehlungen: GO-Sprach-Tutorial

Gewöhnlicher SQL-Ausführungsverarbeitungsprozess:

1. Bereiten Sie die SQL-Anweisung auf dem Client vor.
2. Senden Sie die SQL-Anweisung auf dem MySQL-Server Ausführungsergebnis an den Client.
4. Vorverarbeitungsausführungsprozess:

SQL in Strukturteil und Datenteil aufteilen

; Wenn Sie eine SQL-Anweisung ausführen, senden Sie zunächst denselben Befehls- und Strukturteil an den MySQL-Server, damit der MySQL-Server die Vorverarbeitung im Voraus durchführen kann (die SQL-Anweisung wird zu diesem Zeitpunkt noch nicht tatsächlich ausgeführt).

1. Um dies sicherzustellen die strukturelle Integrität der SQL-Anweisung, wenn die SQL-Anweisung zum ersten Mal gesendet wird, werden die variablen Datenteile durch einen Datenplatzhalter dargestellt und dann wird der Datenteil an den MySQL-Server gesendet Der MySQL-Server ersetzt die Platzhalter der SQL-Anweisung;
2. Der MySQL-Server führt die vollständige SQL-Anweisung aus und gibt das Ergebnis an den Client zurück.
4. Vorteile der Vorverarbeitung

Vorverarbeitungsanweisungen erheblich

Analysezeit reduzieren, es wird nur eine Abfrage durchgeführt (obwohl die Anweisung mehrere ist). Ausführungen);

Bindungsparameter

Reduziert die Serverbandbreite
• durch Senden nur der Parameter der Abfrage anstelle der gesamten Anweisung Ziel der vorbereiteten Anweisungen ist ** SQL-Injection** Sehr nützlich, da nach dem Senden des Parameterwerts unterschiedliche Protokolle verwendet werden, um die Rechtmäßigkeit der Daten sicherzustellen.
Go-Sprachimplementierung
• In der Go-Sprache verwenden Sie die Methode

, um die Vorverarbeitung zu implementieren:

func (db *DB) Prepare(query string) (*Stmt, error)

Prepare führt die Vorverarbeitungs-SQL-Anweisung aus und gibt den Stmt-Strukturzeiger für Datenbindungsvorgänge zurück.

Abfrageoperationen verwenden die Methode

, um Vorverarbeitungs-SQL zu deklarieren, verwenden db.Prepare(), um Platzhalter durch Daten für die Abfrage zu ersetzen, und Aktualisierungs-, Einfügungs- und Löschvorgänge mithilfe von

.

db.Prepare()Beispiel für eine Vorverarbeitungsabfragestmt.Query()

// 预处理查询数据func prepareQuery() {
    sqlStr := "SELECT id,name,age FROM user WHERE id > ?"
    stmt, err := db.Prepare(sqlStr)
    if err != nil {
        fmt.Printf("prepare sql failed, err:%v\n", err)
        return
    }
    rows, err := stmt.Query(1)
    if err != nil {
        fmt.Printf("exec failed, err:%v\n", err)
        return
    }
    defer rows.Close()

    for rows.Next() {
        var u user
        err := rows.Scan(&u.id, &u.name, &u.age)
        if err != nil {
            fmt.Printf("scan data failed, err:%v\n", err)
            return
        }
        fmt.Printf("id:%d, name:%s, age:%d\n", u.id, u.name, u.age)
    }}

stmt.Exec()

Beispiel für eine Vorverarbeitungsaktualisierung

// 预处理更新数据func prepareUpdate() {
    sqlStr := "UPDATE user SET age = ? WHERE id = ?"
    stmt, err := db.Prepare(sqlStr)
    if err != nil {
        fmt.Printf("prepare sql failed, err:%v\n", err)
        return
    }
    _, err = stmt.Exec(18, 2)
    if err != nil {
        fmt.Printf("exec failed, err:%v\n", err)
        return
    }
    fmt.Printf("prepare update data success")}

Beispiel für eine Vorverarbeitungseinfügung

// 预处理更新数据func prepareUpdate() {
    sqlStr := "UPDATE user SET age = ? WHERE id = ?"
    stmt, err := db.Prepare(sqlStr)
    if err != nil {
        fmt.Printf("prepare sql failed, err:%v\n", err)
        return
    }
    _, err = stmt.Exec(18, 2)
    if err != nil {
        fmt.Printf("exec failed, err:%v\n", err)
        return
    }
    fmt.Printf("prepare update data success")}

Vorverarbeitungs-Löschbeispiel

// 预处理删除数据func prepareDelete() {
    sqlStr := "DELETE FROM user WHERE id = ?"
    stmt, err := db.Prepare(sqlStr)
    if err != nil {
        fmt.Printf("prepare sql failed, err:%v\n", err)
        return
    }
    result, err := stmt.Exec(3)
    n, err := result.RowsAffected()
    if err != nil {
        fmt.Printf("delete rows failed, err:%v\n", err)
        return
    }
    if n > 0 {
        fmt.Printf("delete data success")
    } else {
        fmt.Printf("delete data error")
    }

Das obige ist der detaillierte Inhalt vonLernen Sie die Go-Sprache, um die MySQL-Vorverarbeitung durchzuführen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!