feat: add helm to go mod (#497)

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

@@ -0,0 +1,226 @@
+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
+}