---
# System prepended metadata

title: PID-847

---

To scan a JSON array from a MySQL database into a Go data structure, you can follow these steps. I will assume you are using the `github.com/go-sql-driver/mysql` package for database access.
1. **Create a Struct for Your Data Type**:
   First, create a Go struct that matches the structure of the JSON array you expect to retrieve from the MySQL database.
   ```go
   type YourStruct struct {
       ID   int    `json:"id"`
       Name string `json:"name"`
       // Add more fields as needed
   }
   ```
2. **Query the JSON Data from MySQL**:
   Write a SQL query to fetch the JSON array from your MySQL database.
   ```go
   query := "SELECT your_json_column FROM your_table WHERE your_condition"
   ```
3. **Scan the JSON Data**:
   Execute the query and scan the JSON data into a Go variable. You can use the `Scan` method provided by the MySQL driver.
   ```go
   var jsonResult string
   if err := db.QueryRow(query).Scan(&jsonResult); err != nil {
       log.Fatal(err)
   }
   ```
4. **Unmarshal the JSON Data**:
   Unmarshal the JSON string into a slice of your Go struct using the `encoding/json` package.
   ```go
   var data []YourStruct
   if err := json.Unmarshal([]byte(jsonResult), &data); err != nil {
       log.Fatal(err)
   }
   ```
   Make sure that the Go struct's field names match the JSON keys to correctly unmarshal the data.

Here's a complete example:
```go
package main

import (
    "database/sql"
    "encoding/json"
    "log"

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

type YourStruct struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
    // Add more fields as needed
}

func main() {
    db, err := sql.Open("mysql", "user:password@tcp(localhost:3306)/your_db")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    query := "SELECT your_json_column FROM your_table WHERE your_condition"
    var jsonResult string
    if err := db.QueryRow(query).Scan(&jsonResult); err != nil {
        log.Fatal(err)
    }

    var data []YourStruct
    if err := json.Unmarshal([]byte(jsonResult), &data); err != nil {
        log.Fatal(err)
    }

    // Now 'data' contains the JSON data from the database in a Go data structure.
}
```
Ensure that you replace `your_json_column`, `your_table`, `your_condition`, and the database connection parameters with your actual values. The provided code demonstrates how to scan a JSON array from a MySQL database and unmarshal it into a Go data structure for further processing.

Alternatively,to scan a JSON array from a MySQL database into a Golang type, you can create a custom type that implements the `sql.Scanner` and `driver.Valuer` interfaces. This will allow you to automatically unmarshal the JSON data into your custom type when scanning rows from the database and marshal it back when inserting or updating rows.

First, let's define a custom type for the JSON array:
```go
type JSONArray []interface{}

func (ja *JSONArray) Scan(src interface{}) error {
    if src == nil {
        *ja = nil
        return nil
    }

    switch src := src.(type) {
    case []byte:
        return json.Unmarshal(src, ja)
    default:
        return fmt.Errorf("cannot scan JSON array from type %T", src)
    }
}

func (ja JSONArray) Value() (driver.Value, error) {
    if ja == nil {
        return nil, nil
    }
    return json.Marshal(ja)
}
```
Now, let's assume you have a `Programs` struct with a `Countries` field of type `JSONArray`:
```go
type Programs struct {
    ID            int       `json:"id"`
    ShortName     string    `json:"short_name"`
    ProgramPoints float64   `json:"program_points"`
    Countries     JSONArray `json:"countries"`
}
```
You can now use the `Scan` method to read the JSON array from the database:
```go
db, err := sql.Open("mysql", "user:password@/dbname")
if err != nil {
    log.Fatal(err)
}

sql := "SELECT id, short_name, program_points, countries FROM programs"
stmt, err := db.Query(sql)
if err != nil {
    log.Fatal(err)
}

var program Programs
for stmt.Next() {
    err = stmt.Scan(&program.ID, &program.ShortName, &program.ProgramPoints, &program.Countries)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Program: %+v\n", program)
}
```
This code will automatically unmarshal the JSON array from the `countries` column in the database into the `Countries` field of the `Programs` struct. Similarly, when inserting or updating rows in the database, the `Value` method will be used to marshal the `Countries` field back into a JSON array.

Remember to import the necessary packages:
```go
import (
    "database/sql"
    "encoding/json"
    "fmt"
    "log"

    _ "github.com/go-sql-driver/mysql"
)
```
With this approach, you can easily handle JSON arrays from MySQL databases in your Golang application.