pq: оставшиеся слоты соединения зарезервированы для соединений суперпользователя без репликации и соединений rds_superuser

Question

Я получаю эту ошибку:

pq: оставшиеся слоты подключения зарезервированы для подключений суперпользователя без репликации и подключений rds_superuser

Я прочитал много статей, но это только решение со стороны базы данных, а не со стороны Голанга. Я не могу изменить конфигурацию базы данных, max_connections уже в 3500

процесс такой: я получаю данные из вызывающего API, затем сохраняю данные ответа в чью-то базу данных напрямую, а не через API

Я попытался добавить time.sleep, повторно использовать http и объединить в пул http, настроить Transport, но, похоже, эта проблема не имеет никакого отношения к соединению.

* я уже проверяю, закрываю ответ. Орган

GET:

client := &http.Client{
    Transport: &http.Transport{
        MaxIdleConns: 100,
        MaxIdleConnsPerHost: 100,
    },
    Timeout: time.Duration(30) * time.Second,
}

req, err := http.NewRequest("GET", magento_url, nil)
response, err := client.Do(req)

if err != nil {
    fmt.Printf("The HTTP request failed with error %s\n", err)
} 

defer response.Body.Close()

body, err := ioutil.ReadAll(response.Body)
if err != nil {
   log.Fatalf("Couldn't parse response body. %+v", err)
}
fmt.Println("Response Body:", string(body)) 

countriesMap := make(map[string]interface{})

err = json.Unmarshal([]byte(body), &countriesMap)
if err != nil {
    panic(err.Error())
}   

for  key,val := range countriesMap {
     if(key=="items"){
        switch concreteVal := val.(type) {
           case []interface{}:
               fmt.Println(key)
               parseArray(val.([]interface{}))

            default:
                fmt.Println(key, ":", concreteVal)

            }
        }
     }

POST:

func parseArray(anArray []interface{}) {
   arrayData := make(map[string]interface{})
   for i, val := range anArray {
       switch concreteVal := val.(type) {
       case map[string]interface{}:
           fmt.Println("Index::", i)

           for key, valLast := range val.(map[string]interface{}) {
               switch concreteValLast := valLast.(type) {

               default:
                   if key=="coupon_code"{
                       arrayData["coupon_code"]=concreteValLast
                   }else if key=="coupon_description"{
                       arrayData["coupon_description"]=concreteValLast
                   }
               }
           }
       default:
           fmt.Println("Index", i, ":", concreteVal)

       }
       dm_connection := []string{"user=",dm_username," password=",dm_password," dbname=",dm_database," port=",dm_port," host=",dm_host};
       db, err := sql.Open("postgres", strings.Join(dm_connection,""))
       if err != nil {
         panic(message)
       }
      defer db.Close()

      var dataField ApiData

      checkingData := `SELECT coupon_code FROM discount WHERE coupon_code = $1`
      err = db.QueryRow(checkingData, arrayData["coupon_code"]).Scan(&dataField.Coupon_code)

            if err != nil {
                if err == sql.ErrNoRows {
                    //INSERT DM
                    InsertDM(db, arrayData)

                }else{
                    fmt.Println(message)
                }
            }
     func InsertDM(db *sql.DB, arrayData map[string]interface{}){

       insertStatement:=`INSERT INTO discount (coupon_code,coupon_description,created_at) VALUES ($1,$2,$3)`
       _,errInsertDM := db.Exec(insertStatement,arrayData["coupon_code"],arrayData["coupon_description"],arrayData["timestamp"])

   // if there is an error inserting, handle it
       if errInsertDM != nil {
           message:=errInsertDM.Error()
          panic(message)
       }

       insertedData++

    }
}

Я ожидал, что он может обрабатывать как 15.000 данных, но эта ошибка всегда появляется как 3000 данных