d20db90cff
it was noticed that if you had a long lived transaction A that
was blocking some other transaction B and A was being aborted
due to retriable errors, then transaction B was never given
priority. this was due to using savepoints to do lightweight
retries.
this behavior was problematic becaue we had some queries blocked
for over 16 hours, so this commit addresses the issue with two
prongs:
1. bound the amount of time we will retry a transaction
2. create new transactions when a retry is needed
the first ensures that we never wait for 16 hours, and the value
chosen is 10 minutes. that should be long enough for an ample
amount of retries for small queries, and huge queries probably
shouldn't be retried, even if possible: it's more preferrable to
find a way to make them smaller.
the second ensures that even in the case of retries, queries that
are blocked on the aborted transaction gain priority to run.
between those two changes, the maximum stall time due to retries
should be bounded to around 10 minutes.
Change-Id: Icf898501ef505a89738820a3fae2580988f9f5f4
24 lines
473 B
Go
24 lines
473 B
Go
// Copyright (C) 2019 Storj Labs, Inc.
|
|
// See LICENSE for copying information.
|
|
|
|
package migrate
|
|
|
|
import (
|
|
"storj.io/storj/private/tagsql"
|
|
)
|
|
|
|
// DBX contains additional methods for migrations.
|
|
type DBX interface {
|
|
tagsql.DB
|
|
Schema() string
|
|
Rebind(string) string
|
|
}
|
|
|
|
// rebind uses Rebind method when the database has the func.
|
|
func rebind(db tagsql.DB, s string) string {
|
|
if dbx, ok := db.(interface{ Rebind(string) string }); ok {
|
|
return dbx.Rebind(s)
|
|
}
|
|
return s
|
|
}
|