Add working tview, add working load ond Tables, remove giu

manager.go

@@ -1,28 +1,66 @@
 package engine
 
 import (
+	"database/sql"
+	"encoding/hex"
 	"errors"
 	"fmt"
 	"io"
 	"log"
 	"slices"
+	"strconv"
 	"strings"
 
-	"git.pablu.de/pablu/sqv-engine/sql"
+	_ "github.com/mattn/go-sqlite3"
+
+	engine "git.pablu.de/pablu/sqv-engine/sql"
 )
 
 type Manager struct {
-	parser *sql.Parser
+	parser *engine.Parser
 
+	conn   *sql.DB
 	tables []Table
 }
 
 func NewManagerFromFile(sqlTxt string) *Manager {
 	return &Manager{
-		parser: sql.NewParser(strings.NewReader(sqlTxt)),
+		parser: engine.NewParser(strings.NewReader(sqlTxt)),
 	}
 }
 
+func NewManager(path string) (*Manager, error) {
+	db, err := sql.Open("sqlite3", path)
+	if err != nil {
+		return nil, err
+	}
+
+	var sqls []string
+	r, err := db.Query("SELECT name, sql FROM sqlite_schema WHERE type = 'table' AND name NOT LIKE 'sqlite_%'")
+	if err != nil {
+		return nil, err
+	}
+
+	for r.Next() {
+		var name, sql string
+
+		if err := r.Scan(&name, &sql); err != nil {
+			return nil, err
+		}
+
+		sqls = append(sqls, sql)
+	}
+
+	schema := strings.Join(sqls, ";")
+	schema += ";"
+	// fmt.Println(schema)
+
+	return &Manager{
+		parser: engine.NewParser(strings.NewReader(schema)),
+		conn:   db,
+	}, nil
+}
+
 func (m *Manager) Start() error {
 	for {
 		stmt, err := m.parser.Parse()
@@ -30,11 +68,11 @@ func (m *Manager) Start() error {
 			fmt.Println("Finished parsing")
 			break
 		} else if err != nil {
-			log.Fatal(err)
+			return err
 		}
 
 		switch v := stmt.(type) {
-		case *sql.CreateTableStatement:
+		case *engine.CreateTableStatement:
 			t, err := m.convertCreateTableStatementToTable(v)
 			if err != nil {
 				return err
@@ -50,7 +88,7 @@ func (m *Manager) Start() error {
 }
 
 func (m *Manager) Refresh(sqlTxt string) error {
-	m.parser = sql.NewParser(strings.NewReader(sqlTxt))
+	m.parser = engine.NewParser(strings.NewReader(sqlTxt))
 	m.tables = make([]Table, 0)
 
 	return m.Start()
@@ -65,14 +103,73 @@ func (m *Manager) GetTable(name string) (Table, bool) {
 		return t.Name == name
 	})
 
-	if index >= 0 {
-		return m.tables[index], true
+	if index < 0 {
+		return Table{}, false
 	}
+	table := m.tables[index]
 
-	return Table{}, false
+	return table, true
 }
 
-func (m *Manager) convertCreateTableStatementToTable(cts *sql.CreateTableStatement) (Table, error) {
+func (m *Manager) LoadTable(table *Table) error {
+	rows, err := m.conn.Query(fmt.Sprintf("SELECT * FROM %v", table.Name))
+	if err != nil {
+		return err
+	}
+	table.Rows = make([]Row, 0)
+
+	for rows.Next() {
+		cols := make([]any, len(table.Columns))
+		for i, column := range table.Columns {
+			switch column.Type {
+			case BLOB:
+				cols[i] = new([]byte)
+			case TEXT:
+				cols[i] = new(string)
+			case INTEGER:
+				cols[i] = new(int)
+			case REAL:
+				cols[i] = new(float64)
+			default:
+				panic("THIS SHOULD NEVER HAPPEN, WE HIT AN UNKNOWN COLUMN.TYPE")
+			}
+		}
+
+		err = rows.Scan(cols...)
+		if err != nil {
+			return err
+		}
+
+		table.Rows = append(table.Rows, Row{
+			Values: anyToStr(cols),
+		})
+	}
+
+	return nil
+}
+
+func anyToStr(a []any) []string {
+	res := make([]string, len(a))
+
+	for i, c := range a {
+		switch v := c.(type) {
+		case *string:
+			res[i] = *v
+		case *int:
+			res[i] = strconv.Itoa(*v)
+		case *float64:
+			res[i] = strconv.FormatFloat(*v, 'f', 2, 64)
+		case *[]byte:
+			res[i] = hex.EncodeToString(*v)
+		default:
+			panic("THIS SHOULD NEVER HAPPEN, WE GOT SERVED AN UNKNOWN TYPE")
+		}
+	}
+
+	return res
+}
+
+func (m *Manager) convertCreateTableStatementToTable(cts *engine.CreateTableStatement) (Table, error) {
 	res := Table{
 		Name:    cts.TableName,
 		Columns: make([]Column, len(cts.Columns)),
@@ -106,8 +203,22 @@ func (m *Manager) convertCreateTableStatementToTable(cts *sql.CreateTableStateme
 			ref = &refTable.Columns[colIndex]
 		}
 
+		var columnType ColumnType
+		switch column.Type {
+		case "REAL":
+			columnType = REAL
+		case "BLOB":
+			columnType = BLOB
+		case "TEXT":
+			columnType = TEXT
+		case "INTEGER":
+			columnType = INTEGER
+		default:
+			panic("This shouldnt happen")
+		}
+
 		res.Columns[i] = Column{
-			Type:      column.Type,
+			Type:      columnType,
 			Name:      column.Name,
 			Reference: ref,
 			Flags:     flags,