From d7bcaf2559998b77fe890ac36c982845354f939a Mon Sep 17 00:00:00 2001 From: Helmut Merz Date: Wed, 3 Apr 2024 18:48:55 +0200 Subject: [PATCH] static container definition, + more minor improvements --- storage/message/message.go | 45 ++++++++++++++++++++------------- storage/storage.go | 25 ++----------------- storage/tracking/tracking.go | 48 +++++++++++++++++++++++------------- 3 files changed, 61 insertions(+), 57 deletions(-) diff --git a/storage/message/message.go b/storage/message/message.go index 2448a4a..0522dcb 100644 --- a/storage/message/message.go +++ b/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{ - ItemFactory: MakeMessage, - TableName: "messages", - HeadFields: []string{"domain", "action", "class", "item"}, - Indexes: [][]string{ - []string{"domain", "action", "class", "item"}, - []string{"domain", "class", "item"}, - }, - Storage: db, - } + return &tracking.Container{container_definition, 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") - //db.Exec(q, msg.Domain(), msg.Action(), msg.Class(), msg.Item(), msg.Payload()) + cont := Messages(db) + 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" -}} - insert into {{ .table }} (domain, action, class, item, payload) - values ($1, $2, $3, $4, $5) {{- end }}` + container_definition = &tracking.ContDef{ + ItemFactory: MakeMessage, + TableName: "messages", + HeadFields: []string{"domain", "action", "class", "item"}, + Indexes: [][]string{ + []string{"domain", "action", "class", "item"}, + []string{"domain", "class", "item"}, + }, + } } diff --git a/storage/storage.go b/storage/storage.go index 49c7763..1cb5ad8 100644 --- a/storage/storage.go +++ b/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) diff --git a/storage/tracking/tracking.go b/storage/tracking/tracking.go index 5b51906..9fdcf40 100644 --- a/storage/tracking/tracking.go +++ b/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 { - return &track{t.TrackId, t.Head, t.TimeStamp, t.Data, t.Container} +func MakeTrack(t *TrackTemplate, cont *Container) Track { + 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{ - ItemFactory: MakeTrack, - TableName: "tracks", - HeadFields: []string{"taskId", "userName"}, - Indexes: [][]string{[]string{"taskId", "userName"}, []string{"userName"}}, - Storage: db, - } + return &Container{container_definition, 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"}, + }, + } +}