139 lines
2.6 KiB
Go
139 lines
2.6 KiB
Go
package engine
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"log"
|
|
"slices"
|
|
"strings"
|
|
|
|
"git.pablu.de/pablu/sqv-engine/sql"
|
|
)
|
|
|
|
type Manager struct {
|
|
parser *sql.Parser
|
|
|
|
tables []Table
|
|
}
|
|
|
|
func NewManagerFromFile(sqlTxt string) *Manager {
|
|
return &Manager{
|
|
parser: sql.NewParser(strings.NewReader(sqlTxt)),
|
|
}
|
|
}
|
|
|
|
func (m *Manager) Start() error {
|
|
for {
|
|
stmt, err := m.parser.Parse()
|
|
if err != nil && errors.Is(err, io.EOF) {
|
|
fmt.Println("Finished parsing")
|
|
break
|
|
} else if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
|
|
switch v := stmt.(type) {
|
|
case *sql.CreateTableStatement:
|
|
t, err := m.convertCreateTableStatementToTable(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
m.tables = append(m.tables, t)
|
|
|
|
default:
|
|
panic("NOT IMPLEMENTED")
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (m *Manager) Refresh(sqlTxt string) error {
|
|
m.parser = sql.NewParser(strings.NewReader(sqlTxt))
|
|
m.tables = make([]Table, 0)
|
|
|
|
return m.Start()
|
|
}
|
|
|
|
func (m *Manager) GetTables() []Table {
|
|
return m.tables
|
|
}
|
|
|
|
func (m *Manager) GetTable(name string) (Table, bool) {
|
|
index := slices.IndexFunc(m.tables, func(t Table) bool {
|
|
return t.Name == name
|
|
})
|
|
|
|
if index >= 0 {
|
|
return m.tables[index], true
|
|
}
|
|
|
|
return Table{}, false
|
|
}
|
|
|
|
func (m *Manager) convertCreateTableStatementToTable(cts *sql.CreateTableStatement) (Table, error) {
|
|
res := Table{
|
|
Name: cts.TableName,
|
|
Columns: make([]Column, len(cts.Columns)),
|
|
Rows: make([]Row, 0),
|
|
}
|
|
|
|
for i, column := range cts.Columns {
|
|
flags := extrasToFlags(column.Extra)
|
|
var ref *Column = nil
|
|
if flags.Has(FOREIGN_KEY) {
|
|
index := slices.IndexFunc(column.Extra, func(c string) bool {
|
|
return strings.HasPrefix(c, "ref")
|
|
})
|
|
refExtra := column.Extra[index]
|
|
refStr := strings.Split(refExtra, " ")[1]
|
|
|
|
s := strings.Split(refStr, ".")
|
|
tableName := s[0]
|
|
columnName := s[1]
|
|
|
|
refTable, ok := m.GetTable(tableName)
|
|
if !ok {
|
|
fmt.Println(m.tables)
|
|
return Table{}, fmt.Errorf("Reference table '%v' not found", tableName)
|
|
}
|
|
|
|
colIndex := slices.IndexFunc(refTable.Columns, func(c Column) bool {
|
|
return c.Name == columnName
|
|
})
|
|
|
|
ref = &refTable.Columns[colIndex]
|
|
}
|
|
|
|
res.Columns[i] = Column{
|
|
Type: column.Type,
|
|
Name: column.Name,
|
|
Reference: ref,
|
|
Flags: flags,
|
|
}
|
|
}
|
|
|
|
return res, nil
|
|
}
|
|
|
|
func extrasToFlags(extras []string) ColumnFlag {
|
|
res := NONE
|
|
for _, extra := range extras {
|
|
|
|
// This is not good
|
|
switch strings.Split(extra, " ")[0] {
|
|
case "PRIMARY_KEY":
|
|
res |= PRIMARY_KEY
|
|
case "ref":
|
|
res |= FOREIGN_KEY
|
|
case "NOT_NULL":
|
|
res |= NOT_NULL
|
|
default:
|
|
log.Panicf("NOT IMPLEMENTED EXTRA: %v", extra)
|
|
}
|
|
}
|
|
|
|
return res
|
|
}
|