Dex's Postgres client currently uses the `timestamp` datatype for storing times. This lops of timezones with no conversion, causing times to lose locality information. We could convert all times to UTC before storing them, but this is a backward incompatible change for upgrades, since the new version of dex would still be reading times from the database with no locality. Because of this intrinsic issue that current Postgres users don't save any timezone data, we chose to treat any existing installation as corrupted and change the datatype used for times to `timestamptz`. This is a breaking change, but it seems hard to offer an alternative that's both correct and backward compatible. Additionally, an internal flag has been added to SQL flavors, `supportsTimezones`. This allows us to handle SQLite3, which doesn't support timezones, while still storing timezones in other flavors. Flavors that don't support timezones are explicitly converted to UTC.
199 lines
5.2 KiB
Go
199 lines
5.2 KiB
Go
// Package sql provides SQL implementations of the storage interface.
|
|
package sql
|
|
|
|
import (
|
|
"database/sql"
|
|
"regexp"
|
|
"time"
|
|
|
|
"github.com/Sirupsen/logrus"
|
|
"github.com/cockroachdb/cockroach-go/crdb"
|
|
|
|
// import third party drivers
|
|
_ "github.com/go-sql-driver/mysql"
|
|
_ "github.com/lib/pq"
|
|
_ "github.com/mattn/go-sqlite3"
|
|
)
|
|
|
|
// flavor represents a specific SQL implementation, and is used to translate query strings
|
|
// between different drivers. Flavors shouldn't aim to translate all possible SQL statements,
|
|
// only the specific queries used by the SQL storages.
|
|
type flavor struct {
|
|
queryReplacers []replacer
|
|
|
|
// Optional function to create and finish a transaction. This is mainly for
|
|
// cockroachdb support which requires special retry logic provided by their
|
|
// client package.
|
|
//
|
|
// This will be nil for most flavors.
|
|
//
|
|
// See: https://github.com/cockroachdb/docs/blob/63761c2e/_includes/app/txn-sample.go#L41-L44
|
|
executeTx func(db *sql.DB, fn func(*sql.Tx) error) error
|
|
|
|
// Does the flavor support timezones?
|
|
supportsTimezones bool
|
|
}
|
|
|
|
// A regexp with a replacement string.
|
|
type replacer struct {
|
|
re *regexp.Regexp
|
|
with string
|
|
}
|
|
|
|
// Match a postgres query binds. E.g. "$1", "$12", etc.
|
|
var bindRegexp = regexp.MustCompile(`\$\d+`)
|
|
|
|
func matchLiteral(s string) *regexp.Regexp {
|
|
return regexp.MustCompile(`\b` + regexp.QuoteMeta(s) + `\b`)
|
|
}
|
|
|
|
var (
|
|
// The "github.com/lib/pq" driver is the default flavor. All others are
|
|
// translations of this.
|
|
flavorPostgres = flavor{
|
|
// The default behavior for Postgres transactions is consistent reads, not consistent writes.
|
|
// For each transaction opened, ensure it has the correct isolation level.
|
|
//
|
|
// See: https://www.postgresql.org/docs/9.3/static/sql-set-transaction.html
|
|
//
|
|
// NOTE(ericchiang): For some reason using `SET SESSION CHARACTERISTICS AS TRANSACTION` at a
|
|
// session level didn't work for some edge cases. Might be something worth exploring.
|
|
executeTx: func(db *sql.DB, fn func(sqlTx *sql.Tx) error) error {
|
|
tx, err := db.Begin()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer tx.Rollback()
|
|
|
|
if _, err := tx.Exec(`SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;`); err != nil {
|
|
return err
|
|
}
|
|
if err := fn(tx); err != nil {
|
|
return err
|
|
}
|
|
return tx.Commit()
|
|
},
|
|
|
|
supportsTimezones: true,
|
|
}
|
|
|
|
flavorSQLite3 = flavor{
|
|
queryReplacers: []replacer{
|
|
{bindRegexp, "?"},
|
|
// Translate for booleans to integers.
|
|
{matchLiteral("true"), "1"},
|
|
{matchLiteral("false"), "0"},
|
|
{matchLiteral("boolean"), "integer"},
|
|
// Translate other types.
|
|
{matchLiteral("bytea"), "blob"},
|
|
{matchLiteral("timestamptz"), "timestamp"},
|
|
// SQLite doesn't have a "now()" method, replace with "date('now')"
|
|
{regexp.MustCompile(`\bnow\(\)`), "date('now')"},
|
|
},
|
|
}
|
|
|
|
// Incomplete.
|
|
flavorMySQL = flavor{
|
|
queryReplacers: []replacer{
|
|
{bindRegexp, "?"},
|
|
},
|
|
}
|
|
|
|
// Not tested.
|
|
flavorCockroach = flavor{
|
|
executeTx: crdb.ExecuteTx,
|
|
}
|
|
)
|
|
|
|
func (f flavor) translate(query string) string {
|
|
// TODO(ericchiang): Heavy cashing.
|
|
for _, r := range f.queryReplacers {
|
|
query = r.re.ReplaceAllString(query, r.with)
|
|
}
|
|
return query
|
|
}
|
|
|
|
// translateArgs translates query parameters that may be unique to
|
|
// a specific SQL flavor. For example, standardizing "time.Time"
|
|
// types to UTC for clients that don't provide timezone support.
|
|
func (c *conn) translateArgs(args []interface{}) []interface{} {
|
|
if c.flavor.supportsTimezones {
|
|
return args
|
|
}
|
|
|
|
for i, arg := range args {
|
|
if t, ok := arg.(time.Time); ok {
|
|
args[i] = t.UTC()
|
|
}
|
|
}
|
|
return args
|
|
}
|
|
|
|
// conn is the main database connection.
|
|
type conn struct {
|
|
db *sql.DB
|
|
flavor flavor
|
|
logger logrus.FieldLogger
|
|
}
|
|
|
|
func (c *conn) Close() error {
|
|
return c.db.Close()
|
|
}
|
|
|
|
// conn implements the same method signatures as encoding/sql.DB.
|
|
|
|
func (c *conn) Exec(query string, args ...interface{}) (sql.Result, error) {
|
|
query = c.flavor.translate(query)
|
|
return c.db.Exec(query, c.translateArgs(args)...)
|
|
}
|
|
|
|
func (c *conn) Query(query string, args ...interface{}) (*sql.Rows, error) {
|
|
query = c.flavor.translate(query)
|
|
return c.db.Query(query, c.translateArgs(args)...)
|
|
}
|
|
|
|
func (c *conn) QueryRow(query string, args ...interface{}) *sql.Row {
|
|
query = c.flavor.translate(query)
|
|
return c.db.QueryRow(query, c.translateArgs(args)...)
|
|
}
|
|
|
|
// ExecTx runs a method which operates on a transaction.
|
|
func (c *conn) ExecTx(fn func(tx *trans) error) error {
|
|
if c.flavor.executeTx != nil {
|
|
return c.flavor.executeTx(c.db, func(sqlTx *sql.Tx) error {
|
|
return fn(&trans{sqlTx, c})
|
|
})
|
|
}
|
|
|
|
sqlTx, err := c.db.Begin()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := fn(&trans{sqlTx, c}); err != nil {
|
|
sqlTx.Rollback()
|
|
return err
|
|
}
|
|
return sqlTx.Commit()
|
|
}
|
|
|
|
type trans struct {
|
|
tx *sql.Tx
|
|
c *conn
|
|
}
|
|
|
|
// trans implements the same method signatures as encoding/sql.Tx.
|
|
|
|
func (t *trans) Exec(query string, args ...interface{}) (sql.Result, error) {
|
|
query = t.c.flavor.translate(query)
|
|
return t.tx.Exec(query, t.c.translateArgs(args)...)
|
|
}
|
|
|
|
func (t *trans) Query(query string, args ...interface{}) (*sql.Rows, error) {
|
|
query = t.c.flavor.translate(query)
|
|
return t.tx.Query(query, t.c.translateArgs(args)...)
|
|
}
|
|
|
|
func (t *trans) QueryRow(query string, args ...interface{}) *sql.Row {
|
|
query = t.c.flavor.translate(query)
|
|
return t.tx.QueryRow(query, t.c.translateArgs(args)...)
|
|
}
|