Récupérer les données de ligne de la table MySQL/Go

Dans cet article, l'éditeur php Xiaoxin vous présentera comment obtenir des données de ligne à partir d'une table MySQL/Go. MySQL est un système de gestion de bases de données relationnelles populaire et Go est un langage de développement puissant. Au cours du processus de développement, nous devons souvent obtenir des données de la base de données et les traiter. Cet article présentera en détail comment utiliser le langage Go pour se connecter à la base de données MySQL et obtenir les données de ligne de la table via des instructions de requête. Que vous soyez un développeur débutant ou expérimenté, cet article vous fournira des conseils utiles et des exemples de code. commençons!

Contenu de la question

D'abord il lit le code pour que vous compreniez sa logique, lors de l'exécution de la procédure stockée je l'ai capturé il m'apporte une table avec les données que je dois retourner, les noms des colonnes me l'apportent mais le les données des colonnes ne m'apportent rien et je n'arrive pas à créer le modèle et la réponse de la procédure stockée a n colonnes avec n noms différents mais les colonnes diffèrent en ayant des données int et des données chaîne, j'ai besoin que vous capturiez le corrigez les données de la colonne car tout fonctionne bien mais les données de la colonne ne fonctionnent pas :

package controllers

import (
    "database/sql"
    "encoding/json"
    "fmt"
    "net/http"

    "github.com/gin-gonic/gin"
)

type RequestData struct {
    FromData map[string]interface{} `json:"fromData"`
    Call     string                 `json:"Call"`
}

func HandleDatos(c *gin.Context) {
    var requestData RequestData

    if err := c.ShouldBindJSON(&requestData); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }

    fmt.Printf("Ejecutando procedimiento almacenado: CALL %s\n", requestData.Call)
    fmt.Printf("Parámetros: %v\n", requestData.FromData)

    var rows *sql.Rows
    var err error

    // Verifica si FromData contiene valores
    if len(requestData.FromData) > 0 {
        // Si hay valores en FromData, crea una consulta con parámetros
        query := "CALL " + requestData.Call + "("
        params := []interface{}{}
        for _, value := range requestData.FromData {
            query += "?, "
            params = append(params, value)
        }
        query = query[:len(query)-2] + ")"

        rows, err = db.Raw(query, params...).Rows()
    } else {
        // Si no hay valores en FromData, ejecuta el procedimiento almacenado sin parámetros
        rows, err = db.Raw("CALL " + requestData.Call).Rows()
    }

    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        return
    }
    defer rows.Close()

    // Convierte los resultados en un mapa
    result := make(map[string]interface{})
    columns, err := rows.Columns()
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        return
    }

    fmt.Printf("Columnas: %v\n", columns) // Punto de impresión

    data := [][]interface{}{} // Almacena los datos de filas
    for rows.Next() {
        values := make([]interface{}, len(columns))
        for i := range columns {
            values[i] = new(interface{})
        }

        if err := rows.Scan(values...); err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
            return
        }

        fmt.Printf("Valores escaneados: %v\n", values) // Punto de impresión

        row := make(map[string]interface{})
        for i, col := range columns {
            val := *(values[i].(*interface{}))
            row[col] = val
        }

        fmt.Printf("Fila escaneada: %v\n", row) // Punto de impresión

        // Agrega esta fila al resultado
        data = append(data, values)
    }

    fmt.Printf("Datos finales: %v\n", data) // Punto de impresión

    if len(data) > 0 {
        result["columns"] = columns
        result["data"] = data
    } else {
        // Si no hay datos, establece un mensaje personalizado
        result["message"] = "Sin datos"
    }

    // Convierte el resultado en JSON y devuelve la respuesta
    responseJSON, err := json.Marshal(result)
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        return
    }

    c.JSON(http.StatusOK, string(responseJSON))
}

Voici ce qu'il me renvoie, il est écrit "columns": ["idPunto", "nombre"] La partie est ok, mais les lignes contenant les données ne correspondent pas à ce que j'attends :

Solution de contournement

Scanner les lignes En cours into interface {} ne convertit pas automatiquement les types SQL en types Go. Au lieu de cela, l'utilisation de la méthode ColumnTypes obtiendra le type de données de chaque colonne, vous permettant d'attribuer dynamiquement le type Go correct. (Le contenu suivant n'a pas été testé et sert uniquement de référence.) Par exemple

for i := range columns {
    // Use the column types to determine the appropriate scan type
    switch columnTypes[i].DatabaseTypeName() {
    case "INT", "TINYINT", "SMALLINT", "MEDIUMINT", "BIGINT":
        scanArgs[i] = new(int64)
    default:
        scanArgs[i] = new(string)
    }

    values[i] = scanArgs[i]
}

Dans votre script :

package controllers

import (
    "database/sql"
    "encoding/json"
    "fmt"
    "net/http"

    "github.com/gin-gonic/gin"
)

type RequestData struct {
    FromData map[string]interface{} `json:"fromData"`
    Call     string                 `json:"Call"`
}

func HandleDatos(c *gin.Context) {
    var requestData RequestData

    if err := c.ShouldBindJSON(&requestData); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }

    fmt.Printf("Ejecutando procedimiento almacenado: CALL %s\n", requestData.Call)
    fmt.Printf("Parámetros: %v\n", requestData.FromData)

    var rows *sql.Rows
    var err error

    // Verifica si FromData contiene valores
    if len(requestData.FromData) > 0 {
        // Si hay valores en FromData, crea una consulta con parámetros
        query := "CALL " + requestData.Call + "("
        params := []interface{}{}
        for _, value := range requestData.FromData {
            query += "?, "
            params = append(params, value)
        }
        query = query[:len(query)-2] + ")"

        rows, err = db.Raw(query, params...).Rows()
    } else {
        // Si no hay valores en FromData, ejecuta el procedimiento almacenado sin parámetros
        rows, err = db.Raw("CALL " + requestData.Call).Rows()
    }

    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        return
    }
    defer rows.Close()

    // Convierte los resultados en un mapa
    result := make(map[string]interface{})
    columns, err := rows.Columns()
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        return
    }

    fmt.Printf("Columnas: %v\n", columns) // Punto de impresión

    data := []map[string]interface{}{} // Almacena los datos de filas

    // Get the column types
    columnTypes, err := rows.ColumnTypes()
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        return
    }

    for rows.Next() {
        values := make([]interface{}, len(columns)
        scanArgs := make([]interface{}, len(columns))

        for i := range columns {
            // Use the column types to determine the appropriate scan type
            switch columnTypes[i].DatabaseTypeName() {
            case "INT", "TINYINT", "SMALLINT", "MEDIUMINT", "BIGINT":
                scanArgs[i] = new(int64)
            default:
                scanArgs[i] = new(string)
            }

            values[i] = scanArgs[i]
        }

        if err := rows.Scan(values...); err != nil {
            c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
            return
        }

        fmt.Printf("Valores escaneados: %v\n", values) // Punto de impresión

        row := make(map[string]interface{})
        for i, col := range columns {
            // Cast the scanned values to the appropriate data types
            switch columnTypes[i].DatabaseTypeName() {
            case "INT", "TINYINT", "SMALLINT", "MEDIUMINT", "BIGINT":
                row[col] = *(scanArgs[i].(*int64))
            default:
                row[col] = *(scanArgs[i].(*string))
            }
        }

        fmt.Printf("Fila escaneada: %v\n", row) // Punto de impresión

        // Agrega esta fila al resultado
        data = append(data, row)
    }

    fmt.Printf("Datos finales: %v\n", data) // Punto de impresión

    if len(data) > 0 {
        result["columns"] = columns
        result["data"] = data
    } else {
        // Si no hay datos, establece un mensaje personalizado
        result["message"] = "Sin datos"
    }

    // Convierte el resultado en JSON y devuelve la respuesta
    responseJSON, err := json.Marshal(result)
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        return
    }

    c.JSON(http.StatusOK, string(responseJSON))
}

nb : Vous devriez pouvoir étendre cette logique à d’autres types de données que vous pourriez rencontrer.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!