fastpastebin/vendor/github.com/pressly/goose/dialect.go

212 lines
5.7 KiB
Go
Raw Normal View History

2018-04-30 18:42:17 +05:00
package goose
import (
"database/sql"
"fmt"
)
// SQLDialect abstracts the details of specific SQL dialects
// for goose's few SQL specific statements
type SQLDialect interface {
2019-10-13 13:55:38 +05:00
createVersionTableSQL() string // sql string to create the db version table
2018-04-30 18:42:17 +05:00
insertVersionSQL() string // sql string to insert the initial version table row
2019-10-13 13:55:38 +05:00
deleteVersionSQL() string // sql string to delete version
2018-04-30 18:42:17 +05:00
dbVersionQuery(db *sql.DB) (*sql.Rows, error)
}
var dialect SQLDialect = &PostgresDialect{}
// GetDialect gets the SQLDialect
func GetDialect() SQLDialect {
return dialect
}
// SetDialect sets the SQLDialect
func SetDialect(d string) error {
switch d {
case "postgres":
dialect = &PostgresDialect{}
case "mysql":
dialect = &MySQLDialect{}
case "sqlite3":
dialect = &Sqlite3Dialect{}
case "redshift":
dialect = &RedshiftDialect{}
2019-10-13 13:55:38 +05:00
case "tidb":
dialect = &TiDBDialect{}
2018-04-30 18:42:17 +05:00
default:
return fmt.Errorf("%q: unknown dialect", d)
}
return nil
}
////////////////////////////
// Postgres
////////////////////////////
// PostgresDialect struct.
type PostgresDialect struct{}
func (pg PostgresDialect) createVersionTableSQL() string {
2019-10-13 13:55:38 +05:00
return fmt.Sprintf(`CREATE TABLE %s (
2018-04-30 18:42:17 +05:00
id serial NOT NULL,
version_id bigint NOT NULL,
is_applied boolean NOT NULL,
tstamp timestamp NULL default now(),
PRIMARY KEY(id)
2019-10-13 13:55:38 +05:00
);`, TableName())
2018-04-30 18:42:17 +05:00
}
func (pg PostgresDialect) insertVersionSQL() string {
2019-10-13 13:55:38 +05:00
return fmt.Sprintf("INSERT INTO %s (version_id, is_applied) VALUES ($1, $2);", TableName())
2018-04-30 18:42:17 +05:00
}
func (pg PostgresDialect) dbVersionQuery(db *sql.DB) (*sql.Rows, error) {
2019-10-13 13:55:38 +05:00
rows, err := db.Query(fmt.Sprintf("SELECT version_id, is_applied from %s ORDER BY id DESC", TableName()))
2018-04-30 18:42:17 +05:00
if err != nil {
return nil, err
}
return rows, err
}
2019-10-13 13:55:38 +05:00
func (pg PostgresDialect) deleteVersionSQL() string {
return fmt.Sprintf("DELETE FROM %s WHERE version_id=$1;", TableName())
}
2018-04-30 18:42:17 +05:00
////////////////////////////
// MySQL
////////////////////////////
// MySQLDialect struct.
type MySQLDialect struct{}
func (m MySQLDialect) createVersionTableSQL() string {
2019-10-13 13:55:38 +05:00
return fmt.Sprintf(`CREATE TABLE %s (
2018-04-30 18:42:17 +05:00
id serial NOT NULL,
version_id bigint NOT NULL,
is_applied boolean NOT NULL,
tstamp timestamp NULL default now(),
PRIMARY KEY(id)
2019-10-13 13:55:38 +05:00
);`, TableName())
2018-04-30 18:42:17 +05:00
}
func (m MySQLDialect) insertVersionSQL() string {
2019-10-13 13:55:38 +05:00
return fmt.Sprintf("INSERT INTO %s (version_id, is_applied) VALUES (?, ?);", TableName())
2018-04-30 18:42:17 +05:00
}
func (m MySQLDialect) dbVersionQuery(db *sql.DB) (*sql.Rows, error) {
2019-10-13 13:55:38 +05:00
rows, err := db.Query(fmt.Sprintf("SELECT version_id, is_applied from %s ORDER BY id DESC", TableName()))
2018-04-30 18:42:17 +05:00
if err != nil {
return nil, err
}
return rows, err
}
2019-10-13 13:55:38 +05:00
func (m MySQLDialect) deleteVersionSQL() string {
return fmt.Sprintf("DELETE FROM %s WHERE version_id=?;", TableName())
}
2018-04-30 18:42:17 +05:00
////////////////////////////
// sqlite3
////////////////////////////
// Sqlite3Dialect struct.
type Sqlite3Dialect struct{}
func (m Sqlite3Dialect) createVersionTableSQL() string {
2019-10-13 13:55:38 +05:00
return fmt.Sprintf(`CREATE TABLE %s (
2018-04-30 18:42:17 +05:00
id INTEGER PRIMARY KEY AUTOINCREMENT,
version_id INTEGER NOT NULL,
is_applied INTEGER NOT NULL,
tstamp TIMESTAMP DEFAULT (datetime('now'))
2019-10-13 13:55:38 +05:00
);`, TableName())
2018-04-30 18:42:17 +05:00
}
func (m Sqlite3Dialect) insertVersionSQL() string {
2019-10-13 13:55:38 +05:00
return fmt.Sprintf("INSERT INTO %s (version_id, is_applied) VALUES (?, ?);", TableName())
2018-04-30 18:42:17 +05:00
}
func (m Sqlite3Dialect) dbVersionQuery(db *sql.DB) (*sql.Rows, error) {
2019-10-13 13:55:38 +05:00
rows, err := db.Query(fmt.Sprintf("SELECT version_id, is_applied from %s ORDER BY id DESC", TableName()))
2018-04-30 18:42:17 +05:00
if err != nil {
return nil, err
}
return rows, err
}
2019-10-13 13:55:38 +05:00
func (m Sqlite3Dialect) deleteVersionSQL() string {
return fmt.Sprintf("DELETE FROM %s WHERE version_id=?;", TableName())
}
2018-04-30 18:42:17 +05:00
////////////////////////////
// Redshift
////////////////////////////
// RedshiftDialect struct.
type RedshiftDialect struct{}
func (rs RedshiftDialect) createVersionTableSQL() string {
2019-10-13 13:55:38 +05:00
return fmt.Sprintf(`CREATE TABLE %s (
2018-04-30 18:42:17 +05:00
id integer NOT NULL identity(1, 1),
version_id bigint NOT NULL,
is_applied boolean NOT NULL,
tstamp timestamp NULL default sysdate,
PRIMARY KEY(id)
2019-10-13 13:55:38 +05:00
);`, TableName())
2018-04-30 18:42:17 +05:00
}
func (rs RedshiftDialect) insertVersionSQL() string {
2019-10-13 13:55:38 +05:00
return fmt.Sprintf("INSERT INTO %s (version_id, is_applied) VALUES ($1, $2);", TableName())
2018-04-30 18:42:17 +05:00
}
func (rs RedshiftDialect) dbVersionQuery(db *sql.DB) (*sql.Rows, error) {
2019-10-13 13:55:38 +05:00
rows, err := db.Query(fmt.Sprintf("SELECT version_id, is_applied from %s ORDER BY id DESC", TableName()))
2018-04-30 18:42:17 +05:00
if err != nil {
return nil, err
}
return rows, err
}
2019-10-13 13:55:38 +05:00
func (rs RedshiftDialect) deleteVersionSQL() string {
return fmt.Sprintf("DELETE FROM %s WHERE version_id=?;", TableName())
}
////////////////////////////
// TiDB
////////////////////////////
// TiDBDialect struct.
type TiDBDialect struct{}
func (m TiDBDialect) createVersionTableSQL() string {
return fmt.Sprintf(`CREATE TABLE %s (
id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT UNIQUE,
version_id bigint NOT NULL,
is_applied boolean NOT NULL,
tstamp timestamp NULL default now(),
PRIMARY KEY(id)
);`, TableName())
}
func (m TiDBDialect) insertVersionSQL() string {
return fmt.Sprintf("INSERT INTO %s (version_id, is_applied) VALUES (?, ?);", TableName())
}
func (m TiDBDialect) dbVersionQuery(db *sql.DB) (*sql.Rows, error) {
rows, err := db.Query(fmt.Sprintf("SELECT version_id, is_applied from %s ORDER BY id DESC", TableName()))
if err != nil {
return nil, err
}
return rows, err
}
func (m TiDBDialect) deleteVersionSQL() string {
return fmt.Sprintf("DELETE FROM %s WHERE version_id=?;", TableName())
}