Scanning results from DB query that contain a % character

I'm reading data from a postgreSQL DB in my GO code, which works smoothly until I try to scan column values of type string containing the character %. The resulting scanned string will contain %!(MISSING) instead of the %.

For example, the string value this is a % test becomes this is a %!t(MISSING)est after being scanned.

I'm using the regular lib/pq driver for go, using database.Query(...).Scan(...) methods.

EDIT: To clarify exactly what I'm doing and how I'm doing it.

I have a function that accepts an HTTP GET request:

func GetItems(w http.ResponseWriter, r *http.Request) {
    // Setting header content type to json
    w.Header().Set("Content-Type", "application/json")
    
    // Calling another function that gets the items from postgres
    // and returns them as []structs
    items := pg.SelectItems(Database)

    // Marshall the []struct into a json byte array
    jsonItems, err := json.Marshal(items)
    
    // return the formatted response
    // I think that's where the problem is happening
    w.WriteHeader(200)
    fmt.Fprintf(w, string(response))
}

... and a function that does the querying and scans the results into GO structs:

func SelectItems (database *sql.DB) []Items {
    var result []Items
    queryStatement := `SELECT item_id,item_value FROM items`

    // Execute the DB Query
    rows, err := database.Query(queryStatement)

    // Loop over rows
    for rows.Next() {
        item := new(Item)
        // Scan values into item's fields
        err = rows.Scan(&item.ItemID, &item.ItemValue)

        if err != nil {
            // append the item to the array to be returned
            result = append(result, item)
        }
    }
    return result
}

... where Items is defined as such:

type Item struct {
    ItemID    string    `json:"item_id"`
    ItemValue string    `json:"item_value"`
}

Note: I know that it's best practice to always handle all the errors, and to be sure to call defer rows.Close() after the DB query.. and I do in my production code, but i omitted them from the question just for the sake of clarity and readability.

You are probably parsing the string using some kind of formatting and therefore the % is being considered as a special character:

a := "hi % 123\n"
fmt.Printf(a)

This outputs hi %!\n(MISSING)

a := "hi % 123\n"
fmt.Println(a)

This on the other hand outputs hi % 123 as expected.

In the first case we are using a function that formats the string, and therefore considers the % a special character, if you want to format a string that contains this character, just escape it:

strings.Replace(str, "%", "%%", -1):

str := "hi % 123\n"
str2 := strings.Replace(str, "%", "%%", -1)
fmt.Printf(str2)

Since we escaped the % this outputs hi % 123

This is probably not a problem with the Scan function, it's a problem of how you are choosing to display the scanned data.

use fmt.Fprint instead of fmt.Fprintf