work in progress: tracking - creaate table 'tracks'

storage/storage.go

@@ -92,15 +92,15 @@ func (db *Storage) Query(process rowsProc, q string, args ...interface{}) error
 	//log.Debug().Str("query", q).Msg(info)
 	rows, err := db.DB.Query(q, args...)
 	if err != nil {
-		return db.logErr(err, info, q)
+		return db.LogErr(err, info, q)
 	}
 	for rows.Next() {
 		if err := process(rows); err != nil {
-			return db.logErr(err, info, q)
+			return db.LogErr(err, info, q)
 		}
 	}
 	if err := rows.Err(); err != nil {
-		return db.logErr(err, info, q)
+		return db.LogErr(err, info, q)
 	}
 	return nil
 }
@@ -110,7 +110,7 @@ func (db *Storage) Exec(q string, args ...interface{}) (int64, error) {
 	//log.Debug().Str("query", q).Msg(info)
 	res, err := db.DB.Exec(q, args...)
 	if err != nil {
-		db.logErr(err, info, q)
+		db.LogErr(err, info, q)
 		return 0, err
 	}
 	nrows, _ := res.RowsAffected()
@@ -125,7 +125,7 @@ func (db *Storage) DropTable(tn string) error {
 func (db *Storage) RunScript(path string) error {
 	b, err := os.ReadFile(path)
 	if err != nil {
-		return db.logErr(err, "sql.Storage.RunScript", path)
+		return db.LogErr(err, "sql.Storage.RunScript", path)
 	}
 	_, err = db.Exec(string(b))
 	return err
@@ -134,7 +134,7 @@ func (db *Storage) RunScript(path string) error {
 func (db *Storage) ParseTemplate(q string) *template.Template {
 	t, err := template.New("sql").Parse(q)
 	if err != nil {
-		db.logErr(err, "sql.Storage.ParseTemplate", q)
+		db.LogErr(err, "sql.Storage.ParseTemplate", q)
 		return nil
 	}
 	return t
@@ -144,7 +144,7 @@ func (db *Storage) BuildQuery(qname, tname string) string {
 	info := "sql.Storage.SetTable"
 	t := db.Sql.Lookup(qname)
 	if t == nil {
-		db.logErr(fmt.Errorf("template not found"), info, qname)
+		db.LogErr(fmt.Errorf("template not found"), info, qname)
 		return ""
 	}
 	if db.Cfg.Schema != "" {
@@ -154,13 +154,13 @@ func (db *Storage) BuildQuery(qname, tname string) string {
 	data := map[string]interface{}{"table": tname}
 	err := t.Execute(&out, data)
 	if err != nil {
-		db.logErr(err, info, fmt.Sprintf("%+v", t))
+		db.LogErr(err, info, fmt.Sprintf("%+v", t))
 		return ""
 	}
 	return out.String()
 }
 
-func (db *Storage) logErr(err error, info, inp string) error {
+func (db *Storage) LogErr(err error, info, inp string) error {
 	log.Error(err).Str("input", inp).Msg(info)
 	db.Errors = append(db.Errors, err)
 	return err

storage/tracking/sql_code.go

@@ -1,15 +1,17 @@
 package tracking
 
-const Sql_table = `
+const sql_table = `
-create table {{ .tablename }} (
+{{- $tablename := .tablename -}}
+create table {{ $tablename }} (
   trackid {{ .idType }} primary key,
-  {{- range .headFields -}}{{ . }} text,
+  {{ range .headFields -}}{{ . }} text,
   {{ end -}}
   timestamp timestamptz default current_timestamp,
   data {{ .jsonType -}}
 );
 
-{{ range $i, $cols := .indexes }}
+{{- range $i, $cols := .indexes }}
-create index idx_{{ .i }} on {{ .tablename }} ({{ .cols }});
+create index idx_{{ $i }} on {{ $tablename }} ({{ $cols }});
 {{- end }}
-create index idx_timestamp on {{ .tablename }} (timestamp);`
+create index idx_timestamp on {{ .tablename }} (timestamp);
+`

storage/tracking/tracking.go

@@ -3,30 +3,60 @@
 package tracking
 
 import (
+	"fmt"
+	"strings"
 	"time"
 
 	lib "git.sr.ht/~cco/go-scopes"
 	sql "git.sr.ht/~cco/go-scopes/storage"
 )
 
-type Track struct {
+type track struct {
 	TrackId   uint
 	Head      map[string]string
 	TimeStamp *time.Time
 	Data      lib.Payload
-	Container *Container
+	Container *container
 }
 
-type Container struct {
+type container struct {
 	headFields []string
-	indexes    [][]string
+	indexes    []string
 	storage    *sql.Storage
 }
 
-func MakeContainer(st *sql.Storage) Container {
+func Container(db *sql.Storage) *container {
-	return Container{
+	return &container{
 		headFields: []string{"taskId", "userName"},
-		indexes:    [][]string{[]string{"taskId", "userName"}, []string{"userName"}},
+		//indexes:    [][]string{[]string{"taskId", "userName"}, []string{"userName"}},
-		storage:    st,
+		indexes: []string{"taskid, username", "username"},
+		storage: db,
 	}
 }
+
+func Create(cont *container) *container {
+	db := cont.storage
+	t := db.ParseTemplate(sql_table)
+	var out strings.Builder
+	data := map[string]interface{}{
+		"tablename":  "tracks",
+		"headFields": cont.headFields,
+		"indexes":    cont.indexes,
+		"idType":     "integer",
+		"jsonType":   "json",
+	}
+	err := t.Execute(&out, data)
+	if err != nil {
+		db.LogErr(err, "storage.tracking.Create", fmt.Sprintf("%+v", t))
+		return nil
+	}
+	sql := out.String()
+	println(sql)
+	_, err = db.Exec(sql)
+	if err != nil {
+		println(err)
+		db.LogErr(err, "storage.tracking.Create", fmt.Sprintf("%+v", t))
+		return nil
+	}
+	return cont
+}

tests/matrix_test.go

@@ -16,7 +16,7 @@ func TestMatrixApp(tb *tbase.T) {
 	t := testing.SetUpApp(tb, etc.ConfigMx())
 	t.Run("app-matrix", MxTest)
 	t.TearDownApp("matrix")
-	t.AssertEqual(t.LogCheck(logfile, true), 13)
+	t.AssertEqual(t.LogCheck(logfile, false), 13)
 }
 
 func MxTest(t *testing.T) {

tests/scopes_test.go

@@ -19,7 +19,7 @@ func TestScopesApp(tb *tbase.T) {
 	t.Run("send", SendTest)
 	t.Run("client", ClientTest)
 	t.TearDownApp("")
-	t.AssertEqual(t.LogCheck("", true), 18)
+	t.AssertEqual(t.LogCheck("", false), 18)
 }
 
 func AppTest(t *testing.T) {

tests/storage_test.go

@@ -68,17 +68,19 @@ func MessageTest(t *testing.T, cfg *sql.Cfg, db *sql.Storage) {
 }
 
 func TrackingTest(t *testing.T, cfg *sql.Cfg, db *sql.Storage) {
-	_ = tracking.Sql_table
+	cont := tracking.Container(db)
-	_ = tracking.MakeContainer(db)
+	tracking.Create(cont)
 }
 
 func resetSqlite(db *sql.Storage) {
 	db.DropTable("test")
+	db.DropTable("tracks")
 	db.Exec(sqlite_create_table)
 }
 
 func resetPgsql(db *sql.Storage) {
 	db.DropTable("test")
+	db.DropTable("tracks")
 	db.Exec(pgsql_create_table)
 }