core: public release

Author: phenpessoa

go.mod

@@ -0,0 +1,3 @@
+module github.com/phenpessoa/sql2go
+
+go 1.21.4

internal/parser/evaluator.go

@@ -0,0 +1,107 @@
+package parser
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"reflect"
+	"strings"
+)
+
+func Parse[T any](dst *T, r io.Reader) error {
+	v := reflect.ValueOf(dst).Elem()
+
+	data, _ := io.ReadAll(r)
+	input := string(data)
+	l := newLexer(input)
+	p := newParser(l)
+	tree := p.parse()
+
+	i := 0
+	for i < len(tree.nodes) {
+		n := tree.nodes[i]
+		switch t := n.(type) {
+		case nodeName:
+			if !t.valid {
+				return errors.New("sql2go: found an empty name")
+			}
+
+			field := v.FieldByName(t.val)
+			if !field.IsValid() || !field.CanSet() || !field.CanInterface() {
+				return fmt.Errorf(
+					"sql2go: field not found or invalid in dst struct: %s",
+					t.val,
+				)
+			}
+
+			if _, ok := field.Interface().(string); !ok {
+				return fmt.Errorf(
+					"sql2go: field %s is not of type string", t.val,
+				)
+			}
+
+			var (
+				query    strings.Builder
+				lastByte byte
+			)
+			i++
+			for _, nn := range tree.nodes[i:] {
+				switch t := nn.(type) {
+				case nodeEnfOfQuery:
+					query.Grow(1)
+					query.WriteByte(';')
+					lastByte = ';'
+				case nodeName:
+					goto out
+				case nodeQuery:
+					val := strings.TrimSpace(t.val)
+					if lastByte == '\'' || lastByte == '"' || lastByte == '`' {
+						query.Grow(len(val) + 1)
+						query.WriteRune(' ')
+					} else {
+						query.Grow(len(val))
+					}
+					query.WriteString(val)
+					lastByte = val[len(val)-1]
+				case nodeStringLiteral:
+					if lastByte != '\n' && lastByte != ' ' {
+						query.Grow(len(t.val) + 3)
+						query.WriteByte(' ')
+					} else {
+						query.Grow(len(t.val) + 2)
+					}
+					query.WriteByte('\'')
+					query.WriteString(t.val)
+					query.WriteByte('\'')
+					lastByte = '\''
+				case nodeIdentifier:
+					if lastByte != '\n' && lastByte != ' ' {
+						query.Grow(len(t.val) + 3)
+						query.WriteByte(' ')
+					} else {
+						query.Grow(len(t.val) + 2)
+					}
+					query.WriteString(t.tok.literal)
+					query.WriteString(t.val)
+					query.WriteString(t.tok.literal)
+					lastByte = t.tok.literal[0]
+				case nodeNewLine:
+					if lastByte != '\n' {
+						query.Grow(1)
+						query.WriteByte('\n')
+					}
+					lastByte = '\n'
+				}
+
+				i++
+			}
+
+		out:
+			field.Set(reflect.ValueOf(strings.TrimSpace(query.String())))
+		default:
+			i++
+		}
+	}
+
+	return nil
+}

internal/parser/evaluator_test.go

@@ -0,0 +1,88 @@
+package parser
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/phenpessoa/sql2go/internal/testdata"
+)
+
+func TestParser(t *testing.T) {
+	type queries struct {
+		Foo            string
+		Bar            string
+		Baz            string
+		Qux            string
+		Quux           string
+		Corge          string
+		Grault         string
+		HardToLex      string
+		Empty          string
+		Garply         string
+		Waldo          string
+		Fred           string
+		Whatif         string
+		WhatAboutThis  string
+		WhatAboutThis2 string
+		Plugh          string
+		Xyzzy          string
+		Thud           string
+	}
+
+	want := queries{
+		Foo:            "SELECT * FROM foo;",
+		Bar:            "SELECT * FROM bar\nWHERE id = 123;",
+		Baz:            "SELECT\n*\nFROM\nbaz\nWHERE\nbaz = 123 AND\nbaz = baz;",
+		Qux:            "SELECT * FROM qux;",
+		Quux:           "SELECT * FROM quux\nWHERE quux = 123;",
+		Corge:          "SELECT '--' FROM corge;",
+		Grault:         "SELECT '\n-- name: Grault\n' FROM grault;",
+		HardToLex:      "SELECT;",
+		Empty:          "",
+		Garply:         "SELECT 'garply-string-literal' FROM garply;",
+		Waldo:          "SELECT \"waldo_identifier_1\" FROM waldo;",
+		Fred:           "SELECT `fred_identifier_2` FROM fred;",
+		Whatif:         "SELECT * FROM whatif;",
+		WhatAboutThis:  "SELECT 'foo--hard--string--literal' FROM whatAboutThis; `foo\"_identifier_3'`",
+		WhatAboutThis2: "SELECT\n`foo\"_identifier_4`",
+		Plugh:          "SELECT * FROM plugh",
+		Xyzzy:          "SELECT * FROM xyzzy",
+		Thud:           "SELECT * FROM thud;\nSELECT * FROM thud2;",
+	}
+
+	f, err := testdata.TestFS.Open("files/initial.sql")
+	if err != nil {
+		t.Errorf("failed to open inital.sql: %s", err)
+		t.FailNow()
+		return
+	}
+
+	var got queries
+	if err := Parse(&got, f); err != nil {
+		t.Errorf("failed to parse initial.sql: %s", err)
+		t.FailNow()
+		return
+	}
+
+	if got != want {
+		t.Error("initial.sql not parsed properly\n")
+		typ := reflect.TypeOf(got)
+		for i := 0; i < typ.NumField(); i++ {
+			f := typ.Field(i)
+			fv1 := reflect.ValueOf(got).Field(i).Interface()
+			fv2 := reflect.ValueOf(want).Field(i).Interface()
+
+			if fv1 == fv2 {
+				continue
+			}
+
+			t.Errorf(
+				"field: %s\nwanted: %#+v\ngot: %#+v\n",
+				f.Name, fv2, fv1,
+			)
+		}
+
+		t.FailNow()
+		return
+	}
+}

internal/parser/lexer.go

@@ -0,0 +1,143 @@
+package parser
+
+import (
+	"strings"
+)
+
+type lexer struct {
+	input   string
+	pos     int
+	readPos int
+	ch      byte
+}
+
+func newLexer(input string) *lexer {
+	l := &lexer{input: strings.ReplaceAll(input, "\r\n", "\n")}
+	l.readChar()
+	return l
+}
+
+func (l *lexer) readChar() {
+	if l.readPos >= len(l.input) {
+		l.ch = 0
+	} else {
+		l.ch = l.input[l.readPos]
+	}
+	l.pos = l.readPos
+	l.readPos++
+}
+
+func (l *lexer) moveBack() {
+	if l.pos > 0 && l.pos < len(l.input) {
+		l.readPos = l.pos
+		l.pos--
+		l.ch = l.input[l.readPos]
+	} else {
+		l.ch = 0
+	}
+}
+
+func (l *lexer) readLine() string {
+	pos := l.pos
+	for l.ch != '\n' {
+		l.readChar()
+	}
+	return l.input[pos:l.pos]
+}
+
+func (l *lexer) peekChar() byte {
+	if l.readPos >= len(l.input) {
+		return 0
+	}
+	return l.input[l.readPos]
+}
+
+const (
+	nameBytes = " name: "
+)
+
+// isName detects if we are in a name token,
+// if true it will consume the bytes
+func (l *lexer) isName() bool {
+	counter := 0
+	for counter < len(nameBytes) &&
+		l.input[l.readPos+counter] == nameBytes[counter] {
+		counter++
+	}
+	if counter == len(nameBytes) {
+		for i := 0; i < len(nameBytes); i++ {
+			l.readChar()
+		}
+		return true
+	}
+	return false
+}
+
+func (l *lexer) skipWhitespace() {
+	for l.ch == ' ' || l.ch == '\t' || l.ch == '\r' {
+		l.readChar()
+	}
+}
+
+func (l *lexer) readRawInput() string {
+	pos := l.pos
+outer:
+	for {
+		switch l.ch {
+		case '-':
+			if l.peekChar() == '-' {
+				break outer
+			}
+		case ';', '\'', '"', '`':
+			break outer
+		case '\n', 0:
+			break outer
+		}
+		l.readChar()
+	}
+	data := l.input[pos:l.pos]
+	l.moveBack()
+	return data
+}
+
+func (l *lexer) nextToken() token {
+	var t token
+
+	l.skipWhitespace()
+
+	switch l.ch {
+	case '-':
+		if l.peekChar() == '-' {
+			l.readChar()
+			if l.isName() {
+				t.literal = "-- name: "
+				t.typ = tokenTypeName
+			} else {
+				t.literal = "--"
+				t.typ = tokenTypeComment
+			}
+		} else {
+			t.typ = tokenTypeUndefined
+		}
+	case '\n':
+		t.typ = tokenTypeNewLine
+		t.literal = "\n"
+	case '"', '`':
+		t.typ = tokenTypeIdentifier
+		t.literal = string(l.ch)
+	case ';':
+		t.typ = tokenTypeSemicolon
+		t.literal = ";"
+	case 0:
+		t.typ = tokenTypeEOF
+	case '\'':
+		t.typ = tokenTypeStringLiteral
+		t.literal = "'"
+	default:
+		t.typ = tokenTypeRawInput
+		t.literal = l.readRawInput()
+	}
+
+	l.readChar()
+	return t
+}