static container definition, + more minor improvements

storage/message/message.go

@@ -14,28 +14,21 @@ func Message(tr tracking.Track) *message {
 	return &message{tr}
 }
 
-func MakeMessage(t *tracking.TrackTemplate) tracking.Track {
+func MakeMessage(t *tracking.TrackTemplate, c *tracking.Container) tracking.Track {
 	if t.Head["domain"] == "" {
 		t.Head["domain"] = "scopes"
 	}
-	return tracking.MakeTrack(t)
+	return tracking.MakeTrack(t, c)
 }
 
 func (msg *message) Domain() string {
 	return msg.Head()["domain"]
 }
 
+// message container
+
 func Messages(db *sql.Storage) *tracking.Container {
-	return &tracking.Container{
+	return &tracking.Container{container_definition, db}
-		ItemFactory: MakeMessage,
-		TableName:   "messages",
-		HeadFields:  []string{"domain", "action", "class", "item"},
-		Indexes: [][]string{
-			[]string{"domain", "action", "class", "item"},
-			[]string{"domain", "class", "item"},
-		},
-		Storage: db,
-	}
 }
 
 func New(cont *tracking.Container, headValues lib.StrSlice, data lib.Map) *message {
@@ -51,12 +44,30 @@ func Store(act lib.Action) bool {
 }
 
 func StoreDB(db *sql.Storage, msg lib.Message) {
-	//q := db.BuildQuery("insert_msg", "messages")
+	cont := Messages(db)
-	//db.Exec(q, msg.Domain(), msg.Action(), msg.Class(), msg.Item(), msg.Payload())
+	t := tracking.TrackTemplate{
+		Head: lib.StrMap{
+			"Domain": msg.Domain(),
+			"Action": msg.Action(),
+			"Class":  msg.Class(),
+			"Item":   msg.Item(),
+		},
+	}
+	cont.Save(&t)
 }
 
+// container definition
+
+var container_definition *tracking.ContDef
+
 func init() {
-	sql.SqlSources += `{{ define "insert_msg" -}}
+	container_definition = &tracking.ContDef{
-	insert into {{ .table }} (domain, action, class, item, payload)
+		ItemFactory: MakeMessage,
-		values ($1, $2, $3, $4, $5) {{- end }}`
+		TableName:   "messages",
+		HeadFields:  []string{"domain", "action", "class", "item"},
+		Indexes: [][]string{
+			[]string{"domain", "action", "class", "item"},
+			[]string{"domain", "class", "item"},
+		},
+	}
 }

storage/storage.go

@@ -4,7 +4,6 @@ import (
 	"database/sql"
 	"fmt"
 	"os"
-	"strings"
 	"text/template"
 
 	lib "git.sr.ht/~cco/go-scopes"
@@ -135,7 +134,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, "storage.RunScript", path)
 	}
 	_, err = db.Exec(string(b))
 	return err
@@ -144,32 +143,12 @@ 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, "storage.ParseTemplate", q)
 		return nil
 	}
 	return t
 }
 
-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)
-		return ""
-	}
-	if db.Cfg.Schema != "" {
-		tname = db.Cfg.Schema + "." + tname
-	}
-	var out strings.Builder
-	data := map[string]interface{}{"table": tname}
-	err := t.Execute(&out, data)
-	if err != nil {
-		db.LogErr(err, info, fmt.Sprintf("%+v", t))
-		return ""
-	}
-	return out.String()
-}
-
 func (db *Storage) LogErr(err error, info, inp string) error {
 	log.Error(err).Str("input", inp).Msg(info)
 	db.Errors = append(db.Errors, err)

storage/tracking/tracking.go

@@ -13,7 +13,7 @@ import (
 	sql "git.sr.ht/~cco/go-scopes/storage"
 )
 
-type ItemFactory func(*TrackTemplate) Track
+type ItemFactory func(*TrackTemplate, *Container) Track
 
 type Track interface {
 	TrackId() lib.Ident
@@ -30,7 +30,6 @@ type TrackTemplate struct {
 	Head      lib.StrMap
 	TimeStamp *time.Time
 	Data      lib.Map
-	Container *Container
 }
 
 // basic track implementation
@@ -43,8 +42,8 @@ type track struct {
 	container *Container
 }
 
-func MakeTrack(t *TrackTemplate) Track {
+func MakeTrack(t *TrackTemplate, cont *Container) Track {
-	return &track{t.TrackId, t.Head, t.TimeStamp, t.Data, t.Container}
+	return &track{t.TrackId, t.Head, t.TimeStamp, t.Data, cont}
 }
 
 func (tr *track) TrackId() lib.Ident {
@@ -76,29 +75,24 @@ func (tr *track) Update(t *TrackTemplate) {
 	if t.Data != nil {
 		tr.data = t.Data
 	}
-	if t.Container != nil {
-		tr.container = t.Container
-	}
 }
 
 // basic container implementation
 
-type Container struct {
+type ContDef struct {
 	ItemFactory ItemFactory
 	TableName   string
 	HeadFields  []string
 	Indexes     [][]string
-	Storage     *sql.Storage
+}
+
+type Container struct {
+	*ContDef
+	Storage *sql.Storage
 }
 
 func Tracks(db *sql.Storage) *Container {
-	return &Container{
+	return &Container{container_definition, db}
-		ItemFactory: MakeTrack,
-		TableName:   "tracks",
-		HeadFields:  []string{"taskId", "userName"},
-		Indexes:     [][]string{[]string{"taskId", "userName"}, []string{"userName"}},
-		Storage:     db,
-	}
 }
 
 func (cont *Container) NewTrack(headValues lib.StrSlice, data lib.Map) Track {
@@ -110,11 +104,15 @@ func (cont *Container) NewTrack(headValues lib.StrSlice, data lib.Map) Track {
 		head[k] = headValues[i]
 	}
 	//tr := &track{head: head, data: data}
-	tr := cont.ItemFactory(&TrackTemplate{Head: head, Data: data, Container: cont})
+	tr := cont.ItemFactory(&TrackTemplate{Head: head, Data: data}, cont)
 	cont.insert(tr)
 	return tr
 }
 
+func (cont *Container) Save(t *TrackTemplate) lib.Ident {
+	return 0
+}
+
 func (cont *Container) insert(tr Track) lib.Ident {
 	var columns []string
 	var values []any
@@ -175,3 +173,19 @@ func (cont *Container) CreateTable() {
 		panic(err)
 	}
 }
+
+// container definition
+
+var container_definition *ContDef
+
+func init() {
+	container_definition = &ContDef{
+		ItemFactory: MakeTrack,
+		TableName:   "tracks",
+		HeadFields:  []string{"taskId", "userName"},
+		Indexes: [][]string{
+			[]string{"taskId", "userName"},
+			[]string{"userName"},
+		},
+	}
+}