Comment puis-je lot sql avec une base de données des paquets.sql

Depuis le db.Exec fonction est variadic, une option (qui en fait ne fait que de faire un seul aller-retour réseau) est de construire l'énoncé de vous-même et de faire exploser les arguments et les transmettre.

Exemple de code:

func BulkInsert(unsavedRows []*ExampleRowStruct) error {
    valueStrings := make([]string, 0, len(unsavedRows))
    valueArgs := make([]interface{}, 0, len(unsavedRows) * 3)
    for _, post := range unsavedRows {
        valueStrings = append(valueStrings, "(?, ?, ?)")
        valueArgs = append(valueArgs, post.Column1)
        valueArgs = append(valueArgs, post.Column2)
        valueArgs = append(valueArgs, post.Column3)
    }
    stmt := fmt.Sprintf("INSERT INTO my_sample_table (column1, column2, column3) VALUES %s", strings.Join(valueStrings, ","))
    _, err := db.Exec(stmt, valueArgs...)
    return err
}

Dans un simple test que j'ai couru, cette solution est environ 4 fois plus rapide, à l'insertion de 10 000 lignes de la Commencer, Préparer, de s'Engager présenté dans l'autre réponse - bien que l'amélioration réelle dépend de votre installation individuelle, les latences réseau, etc.

Expansion sur Avi Lin réponse, j'avais besoin d'un CONFLIT N'clause de mise à JOUR dans mon INSERT.

La solution est de COPIER une table temporaire (à supprimer à la fin de la transaction), puis l'INSÉRER à partir de la table temporaire à la table permanente.

Voici le code que j'ai réglé sur:

func (fdata *FDataStore) saveToDBBulk(items map[fdataKey][]byte) (err error) {
tx, err := fdata.db.Begin()
if err != nil {
return errors.Wrap(err, "begin transaction")
}
txOK := false
defer func() {
if !txOK {
tx.Rollback()
}
}()
//The ON COMMIT DROP clause at the end makes sure that the table
//is cleaned up at the end of the transaction.
//While the "for{..} state machine" goroutine in charge of delayed
//saving ensures this function is not running twice at any given time.
_, err = tx.Exec(sqlFDataMakeTempTable)
//CREATE TEMPORARY TABLE fstore_data_load
//(map text NOT NULL, key text NOT NULL, data json)
//ON COMMIT DROP
if err != nil {
return errors.Wrap(err, "create temporary table")
}
stmt, err := tx.Prepare(pq.CopyIn(_sqlFDataTempTableName, "map", "key", "data"))
for key, val := range items {
_, err = stmt.Exec(string(key.Map), string(key.Key), string(val))
if err != nil {
return errors.Wrap(err, "loading COPY data")
}
}
_, err = stmt.Exec()
if err != nil {
return errors.Wrap(err, "flush COPY data")
}
err = stmt.Close()
if err != nil {
return errors.Wrap(err, "close COPY stmt")
}
_, err = tx.Exec(sqlFDataSetFromTemp)
//INSERT INTO fstore_data (map, key, data)
//SELECT map, key, data FROM fstore_data_load
//ON CONFLICT DO UPDATE SET data = EXCLUDED.data
if err != nil {
return errors.Wrap(err, "move from temporary to real table")
}
err = tx.Commit()
if err != nil {
return errors.Wrap(err, "commit transaction")
}
txOK = true
return nil
}

Ici est un regard sur @Debasish Mitra's solution si vous utilisez Postgres.

Fonctionnement exemple: https://play.golang.org/p/dFFD2MrEy3J

Autre exemple: https://play.golang.org/p/vUtW0K4jVMd

data := []Person{{"John", "Doe", 27}, {"Leeroy", "Jenkins", 19}}
vals := []interface{}{}
for _, row := range data {
vals = append(vals, row.FirstName, row.LastName, row.Age)
}
sqlStr := `INSERT INTO test(column1, column2, column3) VALUES %s`
sqlStr = ReplaceSQL(sqlStr, "(?, ?, ?)", len(data))
//Prepare and execute the statement
stmt, _ := db.Prepare(sqlStr)
res, _ := stmt.Exec(vals...)

func ReplaceSQL

func ReplaceSQL(stmt, pattern string, len int) string {
pattern += ","
stmt = fmt.Sprintf(stmt, strings.Repeat(pattern, len))
n := 0
for strings.IndexByte(stmt, '?') != -1 {
n++
param := "$" + strconv.Itoa(n)
stmt = strings.Replace(stmt, "?", param, 1)
}
return strings.TrimSuffix(stmt, ",")
}

Pour Postgres lib pq prend en charge des insertions: https://godoc.org/github.com/lib/pq#hdr-Bulk_imports

Mais la même chose peut être atteint par le biais de code ci-dessous mais où il est vraiment utile c'est lorsque l'on tente d'effectuer en vrac conditionnelle de mise à jour (modifier la requête en conséquence).

Pour la réalisation de semblables insertions pour Postgres, vous pouvez utiliser la fonction suivante.

//ReplaceSQL replaces the instance occurrence of any string pattern with an increasing $n based sequence
func ReplaceSQL(old, searchPattern string) string {
tmpCount := strings.Count(old, searchPattern)
for m := 1; m <= tmpCount; m++ {
old = strings.Replace(old, searchPattern, "$"+strconv.Itoa(m), 1)
}
return old
}

Donc au-dessus de l'échantillon devient

sqlStr := "INSERT INTO test(n1, n2, n3) VALUES "
vals := []interface{}{}
for _, row := range data {
sqlStr += "(?, ?, ?)," //Put "?" symbol equal to number of columns
vals = append(vals, row["v1"], row["v2"], row["v3"]) //Put row["v{n}"] blocks equal to number of columns
}
//trim the last ,
sqlStr = strings.TrimSuffix(sqlStr, ",")
//Replacing ? with $n for postgres
sqlStr = ReplaceSQL(sqlStr, "?")
//prepare the statement
stmt, _ := db.Prepare(sqlStr)
//format all vals at once
res, _ := stmt.Exec(vals...)

Une bonne bibliothèque pour chercher la chaîne syntaxe est go-pg

https://github.com/go-pg/pg/wiki/Writing-Queries#insert

Insérer plusieurs livres avec une seule requête:

err := db.Model(book1, book2).Insert()