niki/vendor/github.com/rubenv/sql-migrate/sqlparse/sqlparse.go

227 lines
5.5 KiB
Go
Raw Permalink Normal View History

2024-02-18 10:42:21 +00:00
package sqlparse
import (
"bufio"
"bytes"
"fmt"
"io"
"strings"
)
const (
sqlCmdPrefix = "-- +migrate "
optionNoTransaction = "notransaction"
)
type ParsedMigration struct {
UpStatements []string
DownStatements []string
DisableTransactionUp bool
DisableTransactionDown bool
}
// LineSeparator can be used to split migrations by an exact line match. This line
// will be removed from the output. If left blank, it is not considered. It is defaulted
// to blank so you will have to set it manually.
// Use case: in MSSQL, it is convenient to separate commands by GO statements like in
// SQL Query Analyzer.
var LineSeparator = ""
func errNoTerminator() error {
if len(LineSeparator) == 0 {
return fmt.Errorf(`ERROR: The last statement must be ended by a semicolon or '-- +migrate StatementEnd' marker.
See https://github.com/rubenv/sql-migrate for details.`)
}
return fmt.Errorf(`ERROR: The last statement must be ended by a semicolon, a line whose contents are %q, or '-- +migrate StatementEnd' marker.
See https://github.com/rubenv/sql-migrate for details.`, LineSeparator)
}
// Checks the line to see if the line has a statement-ending semicolon
// or if the line contains a double-dash comment.
func endsWithSemicolon(line string) bool {
prev := ""
scanner := bufio.NewScanner(strings.NewReader(line))
scanner.Split(bufio.ScanWords)
for scanner.Scan() {
word := scanner.Text()
if strings.HasPrefix(word, "--") {
break
}
prev = word
}
return strings.HasSuffix(prev, ";")
}
type migrationDirection int
const (
directionNone migrationDirection = iota
directionUp
directionDown
)
type migrateCommand struct {
Command string
Options []string
}
func (c *migrateCommand) HasOption(opt string) bool {
for _, specifiedOption := range c.Options {
if specifiedOption == opt {
return true
}
}
return false
}
func parseCommand(line string) (*migrateCommand, error) {
cmd := &migrateCommand{}
if !strings.HasPrefix(line, sqlCmdPrefix) {
return nil, fmt.Errorf("ERROR: not a sql-migrate command")
}
fields := strings.Fields(line[len(sqlCmdPrefix):])
if len(fields) == 0 {
return nil, fmt.Errorf(`ERROR: incomplete migration command`)
}
cmd.Command = fields[0]
cmd.Options = fields[1:]
return cmd, nil
}
// Split the given sql script into individual statements.
//
// The base case is to simply split on semicolons, as these
// naturally terminate a statement.
//
// However, more complex cases like pl/pgsql can have semicolons
// within a statement. For these cases, we provide the explicit annotations
// 'StatementBegin' and 'StatementEnd' to allow the script to
// tell us to ignore semicolons.
func ParseMigration(r io.ReadSeeker) (*ParsedMigration, error) {
p := &ParsedMigration{}
_, err := r.Seek(0, 0)
if err != nil {
return nil, err
}
var buf bytes.Buffer
scanner := bufio.NewScanner(r)
scanner.Buffer(make([]byte, 0, 64*1024), 1024*1024)
statementEnded := false
ignoreSemicolons := false
currentDirection := directionNone
for scanner.Scan() {
line := scanner.Text()
// ignore comment except beginning with '-- +'
if strings.HasPrefix(line, "-- ") && !strings.HasPrefix(line, "-- +") {
continue
}
// handle any migrate-specific commands
if strings.HasPrefix(line, sqlCmdPrefix) {
cmd, err := parseCommand(line)
if err != nil {
return nil, err
}
switch cmd.Command {
case "Up":
if len(strings.TrimSpace(buf.String())) > 0 {
return nil, errNoTerminator()
}
currentDirection = directionUp
if cmd.HasOption(optionNoTransaction) {
p.DisableTransactionUp = true
}
case "Down":
if len(strings.TrimSpace(buf.String())) > 0 {
return nil, errNoTerminator()
}
currentDirection = directionDown
if cmd.HasOption(optionNoTransaction) {
p.DisableTransactionDown = true
}
case "StatementBegin":
if currentDirection != directionNone {
ignoreSemicolons = true
}
case "StatementEnd":
if currentDirection != directionNone {
statementEnded = ignoreSemicolons
ignoreSemicolons = false
}
}
}
if currentDirection == directionNone {
continue
}
isLineSeparator := !ignoreSemicolons && len(LineSeparator) > 0 && line == LineSeparator
if !isLineSeparator && !strings.HasPrefix(line, "-- +") {
if _, err := buf.WriteString(line + "\n"); err != nil {
return nil, err
}
}
// Wrap up the two supported cases: 1) basic with semicolon; 2) psql statement
// Lines that end with semicolon that are in a statement block
// do not conclude statement.
if (!ignoreSemicolons && (endsWithSemicolon(line) || isLineSeparator)) || statementEnded {
statementEnded = false
switch currentDirection {
case directionUp:
p.UpStatements = append(p.UpStatements, buf.String())
case directionDown:
p.DownStatements = append(p.DownStatements, buf.String())
default:
panic("impossible state")
}
buf.Reset()
}
}
if err := scanner.Err(); err != nil {
return nil, err
}
// diagnose likely migration script errors
if ignoreSemicolons {
return nil, fmt.Errorf("ERROR: saw '-- +migrate StatementBegin' with no matching '-- +migrate StatementEnd'")
}
if currentDirection == directionNone {
return nil, fmt.Errorf(`ERROR: no Up/Down annotations found, so no statements were executed.
See https://github.com/rubenv/sql-migrate for details.`)
}
// allow comment without sql instruction. Example:
// -- +migrate Down
// -- nothing to downgrade!
if len(strings.TrimSpace(buf.String())) > 0 && !strings.HasPrefix(buf.String(), "-- +") {
return nil, errNoTerminator()
}
return p, nil
}