472 lines
17 KiB
Go
472 lines
17 KiB
Go
package store
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"encoding/json"
|
|
"errors"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
"pageswiki/internal/db"
|
|
)
|
|
|
|
var taskProductivityMigrations = []db.SQLMigration{{Version: 1, Name: "task_capture_work_and_reporting", Statements: []string{
|
|
`CREATE TABLE organizer_task_preferences(domain_uuid TEXT NOT NULL,owner_uuid TEXT NOT NULL,version INTEGER NOT NULL,data TEXT NOT NULL,next_digest_ms INTEGER NOT NULL DEFAULT 0,PRIMARY KEY(domain_uuid,owner_uuid))`,
|
|
`CREATE INDEX organizer_digest_due ON organizer_task_preferences(next_digest_ms) WHERE next_digest_ms>0`,
|
|
`CREATE TABLE organizer_capture_receipts(domain_uuid TEXT NOT NULL,owner_uuid TEXT NOT NULL,request_uuid TEXT NOT NULL,request_hash TEXT NOT NULL,item_uuid TEXT NOT NULL,PRIMARY KEY(domain_uuid,owner_uuid,request_uuid))`,
|
|
`CREATE TABLE organizer_work_sessions(uuid TEXT PRIMARY KEY,domain_uuid TEXT NOT NULL,owner_uuid TEXT NOT NULL,task_uuid TEXT NOT NULL,start_ms INTEGER NOT NULL,end_ms INTEGER NOT NULL DEFAULT 0,version INTEGER NOT NULL DEFAULT 1)`,
|
|
`CREATE UNIQUE INDEX organizer_work_active ON organizer_work_sessions(owner_uuid) WHERE end_ms=0`,
|
|
`CREATE INDEX organizer_work_period ON organizer_work_sessions(domain_uuid,owner_uuid,start_ms,uuid)`,
|
|
`CREATE TABLE organizer_task_metrics(domain_uuid TEXT NOT NULL,owner_uuid TEXT NOT NULL,task_uuid TEXT NOT NULL,completed_ms INTEGER NOT NULL,estimate INTEGER NOT NULL,complexity INTEGER NOT NULL,PRIMARY KEY(domain_uuid,task_uuid))`,
|
|
`CREATE INDEX organizer_task_completed ON organizer_task_metrics(domain_uuid,owner_uuid,completed_ms)`,
|
|
`INSERT INTO organizer_task_metrics SELECT domain_uuid,owner_uuid,uuid,COALESCE(json_extract(data,'$.completed_at_ms'),0),COALESCE(json_extract(data,'$.estimate_minutes'),0),max(1,COALESCE(json_extract(data,'$.complexity'),1)) FROM organizer_items WHERE kind='task'`,
|
|
`CREATE TABLE organizer_digest_deliveries(domain_uuid TEXT NOT NULL,owner_uuid TEXT NOT NULL,day TEXT NOT NULL,state TEXT NOT NULL,updated_ms INTEGER NOT NULL,PRIMARY KEY(domain_uuid,owner_uuid,day))`,
|
|
}, Assertions: []string{
|
|
schemaColumns("organizer_task_preferences", "domain_uuid,owner_uuid,version,data,next_digest_ms"),
|
|
schemaUnique("organizer_capture_receipts", "domain_uuid,owner_uuid,request_uuid"),
|
|
schemaIndex("organizer_work_sessions", "organizer_work_period", "domain_uuid,owner_uuid,start_ms,uuid"),
|
|
}}, {Version: 2, Name: "personal_dashboard_layout", Statements: []string{
|
|
`CREATE TABLE organizer_dashboard_layouts(domain_uuid TEXT NOT NULL,owner_uuid TEXT NOT NULL,version INTEGER NOT NULL,data TEXT NOT NULL,PRIMARY KEY(domain_uuid,owner_uuid))`,
|
|
}, Assertions: []string{schemaColumns("organizer_dashboard_layouts", "domain_uuid,owner_uuid,version,data"), schemaUnique("organizer_dashboard_layouts", "domain_uuid,owner_uuid")}}}
|
|
|
|
type TaskPreferences struct {
|
|
Version int64 `json:"version"`
|
|
ProjectUUID string `json:"project_uuid"`
|
|
AssigneeUUID string `json:"assignee_uuid"`
|
|
DueDays *int `json:"due_days"`
|
|
StartDays *int `json:"start_days"`
|
|
PlannedDays *int `json:"planned_days"`
|
|
ReviewDays *int `json:"review_days"`
|
|
Estimate int `json:"estimate_minutes"`
|
|
Complexity int `json:"complexity"`
|
|
NotifyDue bool `json:"notify_due"`
|
|
NotifyPlanned bool `json:"notify_planned"`
|
|
ReminderTime string `json:"reminder_time"`
|
|
DigestEnabled bool `json:"digest_enabled"`
|
|
DigestTime string `json:"digest_time"`
|
|
Timezone string `json:"timezone"`
|
|
}
|
|
|
|
func (s *Store) TaskPreferences(ctx context.Context, domain, actor string) (TaskPreferences, error) {
|
|
p := TaskPreferences{AssigneeUUID: actor, Complexity: 1, ReminderTime: "09:00", DigestTime: "09:00", Timezone: "UTC"}
|
|
if err := taskActor(ctx, s.DB, domain, actor, false); err != nil {
|
|
return p, err
|
|
}
|
|
var raw string
|
|
err := s.DB.QueryRowContext(ctx, `SELECT data FROM organizer_task_preferences WHERE domain_uuid=? AND owner_uuid=?`, domain, actor).Scan(&raw)
|
|
if errors.Is(err, sql.ErrNoRows) {
|
|
return p, nil
|
|
}
|
|
if err != nil {
|
|
return p, err
|
|
}
|
|
err = json.Unmarshal([]byte(raw), &p)
|
|
return p, err
|
|
}
|
|
|
|
func nextTaskDigest(now time.Time, p TaskPreferences) (int64, error) {
|
|
loc, err := time.LoadLocation(p.Timezone)
|
|
if err != nil {
|
|
return 0, ErrTaskInvalid
|
|
}
|
|
clock, err := time.Parse("15:04", p.DigestTime)
|
|
if err != nil || clock.Format("15:04") != p.DigestTime {
|
|
return 0, ErrTaskInvalid
|
|
}
|
|
if !p.DigestEnabled {
|
|
return 0, nil
|
|
}
|
|
t := now.In(loc)
|
|
candidate := time.Date(t.Year(), t.Month(), t.Day(), clock.Hour(), clock.Minute(), 0, 0, loc)
|
|
if !candidate.After(now) {
|
|
candidate = time.Date(t.Year(), t.Month(), t.Day()+1, clock.Hour(), clock.Minute(), 0, 0, loc)
|
|
}
|
|
return candidate.UnixMilli(), nil
|
|
}
|
|
|
|
func (s *Store) SaveTaskPreferences(ctx context.Context, domain, actor string, p TaskPreferences, now time.Time) (TaskPreferences, error) {
|
|
if s.ReadOnly {
|
|
return p, ErrReadOnly
|
|
}
|
|
// Older clients do not send this field. Preserve their default clock.
|
|
if p.ReminderTime == "" {
|
|
p.ReminderTime = "09:00"
|
|
}
|
|
clock, clockErr := time.Parse("15:04", p.ReminderTime)
|
|
if clockErr != nil || clock.Format("15:04") != p.ReminderTime {
|
|
return p, ErrTaskInvalid
|
|
}
|
|
for _, n := range []*int{p.DueDays, p.StartDays, p.PlannedDays, p.ReviewDays} {
|
|
if n != nil && (*n < 0 || *n > 3650) {
|
|
return p, ErrTaskInvalid
|
|
}
|
|
}
|
|
if p.Estimate < 0 || p.Estimate > 10080 || p.Complexity < 1 || p.Complexity > 5 || p.Version < 0 {
|
|
return p, ErrTaskInvalid
|
|
}
|
|
next, err := nextTaskDigest(now, p)
|
|
if err != nil {
|
|
return p, err
|
|
}
|
|
tx, err := s.DB.BeginTx(ctx, nil)
|
|
if err != nil {
|
|
return p, err
|
|
}
|
|
defer tx.Rollback()
|
|
if err = taskProductivityWriter(ctx, tx, domain, actor); err != nil {
|
|
return p, err
|
|
}
|
|
if err = validateTaskAssignee(ctx, tx, domain, p.AssigneeUUID); err != nil {
|
|
return p, err
|
|
}
|
|
if p.ProjectUUID != "" {
|
|
var yes bool
|
|
if err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM organizer_items WHERE domain_uuid=? AND owner_uuid=? AND uuid=? AND kind='project' AND archived=0)`, domain, actor, p.ProjectUUID).Scan(&yes); err != nil {
|
|
return p, err
|
|
}
|
|
if !yes {
|
|
return p, ErrTaskInvalid
|
|
}
|
|
}
|
|
var current int64
|
|
err = tx.QueryRowContext(ctx, `SELECT version FROM organizer_task_preferences WHERE domain_uuid=? AND owner_uuid=?`, domain, actor).Scan(¤t)
|
|
if err != nil && !errors.Is(err, sql.ErrNoRows) {
|
|
return p, err
|
|
}
|
|
if current != p.Version {
|
|
return p, ErrTaskConflict
|
|
}
|
|
p.Version++
|
|
raw, _ := json.Marshal(p)
|
|
_, err = tx.ExecContext(ctx, `INSERT INTO organizer_task_preferences VALUES(?,?,?,?,?) ON CONFLICT(domain_uuid,owner_uuid) DO UPDATE SET version=excluded.version,data=excluded.data,next_digest_ms=excluded.next_digest_ms`, domain, actor, p.Version, string(raw), next)
|
|
if err != nil {
|
|
return p, err
|
|
}
|
|
return p, tx.Commit()
|
|
}
|
|
|
|
func taskProductivityWriter(ctx context.Context, tx *sql.Tx, domain, actor string) error {
|
|
if _, err := tx.ExecContext(ctx, `UPDATE domain_memberships SET state=state WHERE domain_uuid=? AND principal_uuid=?`, domain, actor); err != nil {
|
|
return err
|
|
}
|
|
if err := taskActor(ctx, tx, domain, actor, true); err != nil {
|
|
return err
|
|
}
|
|
on, err := taskReminderExtensionEnabled(ctx, tx, domain)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !on {
|
|
return ErrAccessDenied
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Assignment is a private planning annotation, NOT a grant to read this task.
|
|
func validateTaskAssignee(ctx context.Context, tx *sql.Tx, domain, assignee string) error {
|
|
if assignee == "" {
|
|
return nil
|
|
}
|
|
if _, err := uuid.Parse(assignee); err != nil {
|
|
return ErrTaskInvalid
|
|
}
|
|
if err := taskActor(ctx, tx, domain, assignee, false); err != nil {
|
|
return ErrTaskInvalid
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *Store) CapturedTask(ctx context.Context, domain, actor, request, hash string) (TaskRecord, error) {
|
|
if err := taskActor(ctx, s.DB, domain, actor, false); err != nil {
|
|
return TaskRecord{}, err
|
|
}
|
|
var stored, id string
|
|
err := s.DB.QueryRowContext(ctx, `SELECT request_hash,item_uuid FROM organizer_capture_receipts WHERE domain_uuid=? AND owner_uuid=? AND request_uuid=?`, domain, actor, request).Scan(&stored, &id)
|
|
if err != nil {
|
|
return TaskRecord{}, err
|
|
}
|
|
if stored != hash {
|
|
return TaskRecord{}, ErrTaskConflict
|
|
}
|
|
return s.GetTask(ctx, domain, actor, id)
|
|
}
|
|
|
|
func (s *Store) CaptureTask(ctx context.Context, domain, actor, request, hash string, item TaskRecord) (TaskRecord, error) {
|
|
if _, err := uuid.Parse(request); err != nil {
|
|
return TaskRecord{}, ErrTaskInvalid
|
|
}
|
|
old, err := s.CapturedTask(ctx, domain, actor, request, hash)
|
|
if err == nil {
|
|
return old, nil
|
|
}
|
|
if !errors.Is(err, sql.ErrNoRows) {
|
|
return old, err
|
|
}
|
|
item.UUID = request
|
|
out, err := s.saveTask(ctx, domain, actor, item, 0, func(tx *sql.Tx, _ *TaskRecord, _ TaskRecord) error {
|
|
_, e := tx.ExecContext(ctx, `INSERT INTO organizer_capture_receipts VALUES(?,?,?,?,?)`, domain, actor, request, hash, item.UUID)
|
|
return e
|
|
})
|
|
if err != nil {
|
|
if old, e := s.CapturedTask(ctx, domain, actor, request, hash); e == nil {
|
|
return old, nil
|
|
}
|
|
}
|
|
return out, err
|
|
}
|
|
|
|
type TaskWork struct {
|
|
UUID string `json:"uuid"`
|
|
TaskUUID string `json:"task_uuid"`
|
|
StartMS int64 `json:"start_ms"`
|
|
EndMS int64 `json:"end_ms"`
|
|
Version int64 `json:"version"`
|
|
}
|
|
|
|
func scanTaskWork(row interface{ Scan(...any) error }) (TaskWork, error) {
|
|
var v TaskWork
|
|
err := row.Scan(&v.UUID, &v.TaskUUID, &v.StartMS, &v.EndMS, &v.Version)
|
|
return v, err
|
|
}
|
|
|
|
const taskWorkColumns = `uuid,task_uuid,start_ms,end_ms,version`
|
|
|
|
func (s *Store) ActiveTaskWork(ctx context.Context, domain, actor string) (*TaskWork, error) {
|
|
if err := taskActor(ctx, s.DB, domain, actor, false); err != nil {
|
|
return nil, err
|
|
}
|
|
v, err := scanTaskWork(s.DB.QueryRowContext(ctx, `SELECT `+taskWorkColumns+` FROM organizer_work_sessions WHERE domain_uuid=? AND owner_uuid=? AND end_ms=0`, domain, actor))
|
|
if errors.Is(err, sql.ErrNoRows) {
|
|
return nil, nil
|
|
}
|
|
return &v, err
|
|
}
|
|
|
|
func (s *Store) ChangeTaskWork(ctx context.Context, domain, actor, action string, v TaskWork, now time.Time) (TaskWork, error) {
|
|
if s.ReadOnly {
|
|
return v, ErrReadOnly
|
|
}
|
|
if _, err := uuid.Parse(v.UUID); err != nil {
|
|
return v, ErrTaskInvalid
|
|
}
|
|
tx, err := s.DB.BeginTx(ctx, nil)
|
|
if err != nil {
|
|
return v, err
|
|
}
|
|
defer tx.Rollback()
|
|
if err = taskProductivityWriter(ctx, tx, domain, actor); err != nil {
|
|
return v, err
|
|
}
|
|
old, err := scanTaskWork(tx.QueryRowContext(ctx, `SELECT `+taskWorkColumns+` FROM organizer_work_sessions WHERE uuid=? AND domain_uuid=? AND owner_uuid=?`, v.UUID, domain, actor))
|
|
if err != nil && !errors.Is(err, sql.ErrNoRows) {
|
|
return v, err
|
|
}
|
|
switch action {
|
|
case "start":
|
|
if v.Version != 0 {
|
|
return v, ErrTaskInvalid
|
|
}
|
|
if err == nil {
|
|
if old.TaskUUID != v.TaskUUID {
|
|
return v, ErrTaskConflict
|
|
}
|
|
return old, tx.Commit()
|
|
}
|
|
var yes bool
|
|
if err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM organizer_items WHERE domain_uuid=? AND owner_uuid=? AND uuid=? AND kind='task' AND archived=0 AND status NOT IN ('done','cancelled'))`, domain, actor, v.TaskUUID).Scan(&yes); err != nil {
|
|
return v, err
|
|
}
|
|
if !yes {
|
|
return v, sql.ErrNoRows
|
|
}
|
|
v.StartMS = now.UnixMilli()
|
|
v.EndMS = 0
|
|
v.Version = 1
|
|
res, e := tx.ExecContext(ctx, `INSERT OR IGNORE INTO organizer_work_sessions(uuid,domain_uuid,owner_uuid,task_uuid,start_ms) VALUES(?,?,?,?,?)`, v.UUID, domain, actor, v.TaskUUID, v.StartMS)
|
|
if e != nil {
|
|
return v, e
|
|
}
|
|
n, _ := res.RowsAffected()
|
|
if n != 1 {
|
|
return v, ErrTaskConflict
|
|
}
|
|
case "stop":
|
|
if err != nil {
|
|
return v, err
|
|
}
|
|
if old.EndMS > 0 {
|
|
if v.Version == old.Version || v.Version == old.Version-1 {
|
|
return old, tx.Commit()
|
|
}
|
|
return v, ErrTaskConflict
|
|
}
|
|
if old.Version != v.Version {
|
|
return v, ErrTaskConflict
|
|
}
|
|
v = old
|
|
v.EndMS = max(v.StartMS, now.UnixMilli())
|
|
v.Version++
|
|
_, err = tx.ExecContext(ctx, `UPDATE organizer_work_sessions SET end_ms=?,version=? WHERE uuid=?`, v.EndMS, v.Version, v.UUID)
|
|
if err != nil {
|
|
return v, err
|
|
}
|
|
default:
|
|
return v, ErrTaskInvalid
|
|
}
|
|
return v, tx.Commit()
|
|
}
|
|
|
|
type TaskReportDay struct {
|
|
Date string `json:"date"`
|
|
Completed int `json:"completed"`
|
|
Points int `json:"points"`
|
|
Estimate int `json:"estimate_minutes"`
|
|
WorkMS int64 `json:"work_ms"`
|
|
FocusMS int64 `json:"focus_ms"`
|
|
}
|
|
type TaskReportItem struct {
|
|
UUID string `json:"uuid"`
|
|
Title string `json:"title"`
|
|
ProjectUUID string `json:"project_uuid"`
|
|
WorkMS int64 `json:"work_ms"`
|
|
Points int `json:"points"`
|
|
Completed bool `json:"completed"`
|
|
}
|
|
type TaskReport struct {
|
|
Days []TaskReportDay `json:"days"`
|
|
Tasks []TaskReportItem `json:"tasks"`
|
|
Sessions []TaskWork `json:"sessions"`
|
|
Partial bool `json:"partial"`
|
|
Timezone string `json:"timezone"`
|
|
}
|
|
|
|
func (s *Store) TaskReport(ctx context.Context, domain, actor string, start, end, now time.Time) (TaskReport, error) {
|
|
out := TaskReport{Days: []TaskReportDay{}, Tasks: []TaskReportItem{}, Sessions: []TaskWork{}, Timezone: start.Location().String()}
|
|
if err := taskActor(ctx, s.DB, domain, actor, false); err != nil {
|
|
return out, err
|
|
}
|
|
if !end.After(start) || end.Sub(start) > 367*24*time.Hour {
|
|
return out, ErrTaskInvalid
|
|
}
|
|
days := map[string]int{}
|
|
for day := start; day.Before(end); day = day.AddDate(0, 0, 1) {
|
|
days[day.Format("2006-01-02")] = len(out.Days)
|
|
out.Days = append(out.Days, TaskReportDay{Date: day.Format("2006-01-02")})
|
|
}
|
|
byTask := map[string]int{}
|
|
rows, err := s.DB.QueryContext(ctx, `SELECT m.completed_ms,m.estimate,m.complexity,m.task_uuid,COALESCE(i.title,''),COALESCE(i.project_uuid,'') FROM organizer_task_metrics m LEFT JOIN organizer_items i ON i.domain_uuid=m.domain_uuid AND i.owner_uuid=m.owner_uuid AND i.uuid=m.task_uuid WHERE m.domain_uuid=? AND m.owner_uuid=? AND m.completed_ms>=? AND m.completed_ms<? ORDER BY m.completed_ms,m.task_uuid LIMIT 10001`, domain, actor, start.UnixMilli(), end.UnixMilli())
|
|
if err != nil {
|
|
return out, err
|
|
}
|
|
n := 0
|
|
for rows.Next() {
|
|
var ms int64
|
|
var estimate, complexity int
|
|
var id, title, project string
|
|
if err = rows.Scan(&ms, &estimate, &complexity, &id, &title, &project); err != nil {
|
|
rows.Close()
|
|
return out, err
|
|
}
|
|
n++
|
|
if n > 10000 {
|
|
out.Partial = true
|
|
break
|
|
}
|
|
if index, ok := days[time.UnixMilli(ms).In(start.Location()).Format("2006-01-02")]; ok {
|
|
d := &out.Days[index]
|
|
d.Completed++
|
|
d.Estimate += estimate
|
|
d.Points += 1 + ((estimate+29)/30)*max(1, complexity)
|
|
byTask[id] = len(out.Tasks)
|
|
out.Tasks = append(out.Tasks, TaskReportItem{UUID: id, Title: title, ProjectUUID: project, Completed: true, Points: 1 + ((estimate+29)/30)*max(1, complexity)})
|
|
}
|
|
}
|
|
err = rows.Err()
|
|
rows.Close()
|
|
if err != nil {
|
|
return out, err
|
|
}
|
|
// Split intervals at local midnight; never assume a day is exactly 24h.
|
|
addSpan := func(a, b int64, focus bool) int64 {
|
|
a = max(a, start.UnixMilli())
|
|
b = min(b, end.UnixMilli(), now.UnixMilli())
|
|
if b <= a {
|
|
return 0
|
|
}
|
|
total := b - a
|
|
for a < b {
|
|
t := time.UnixMilli(a).In(start.Location())
|
|
next := time.Date(t.Year(), t.Month(), t.Day()+1, 0, 0, 0, 0, t.Location()).UnixMilli()
|
|
stop := min(next, b)
|
|
if index, ok := days[t.Format("2006-01-02")]; ok {
|
|
if focus {
|
|
out.Days[index].FocusMS += stop - a
|
|
} else {
|
|
out.Days[index].WorkMS += stop - a
|
|
}
|
|
}
|
|
a = stop
|
|
}
|
|
return total
|
|
}
|
|
rows, err = s.DB.QueryContext(ctx, `SELECT w.uuid,w.task_uuid,w.start_ms,w.end_ms,w.version,COALESCE(i.title,''),COALESCE(i.project_uuid,'') FROM organizer_work_sessions w LEFT JOIN organizer_items i ON i.domain_uuid=w.domain_uuid AND i.owner_uuid=w.owner_uuid AND i.uuid=w.task_uuid WHERE w.domain_uuid=? AND w.owner_uuid=? AND w.start_ms<? AND (w.end_ms=0 OR w.end_ms>?) ORDER BY w.start_ms DESC,w.uuid LIMIT 10001`, domain, actor, end.UnixMilli(), start.UnixMilli())
|
|
if err != nil {
|
|
return out, err
|
|
}
|
|
n = 0
|
|
for rows.Next() {
|
|
var v TaskWork
|
|
var title, project string
|
|
if err = rows.Scan(&v.UUID, &v.TaskUUID, &v.StartMS, &v.EndMS, &v.Version, &title, &project); err != nil {
|
|
rows.Close()
|
|
return out, err
|
|
}
|
|
n++
|
|
if n > 10000 {
|
|
out.Partial = true
|
|
break
|
|
}
|
|
finish := v.EndMS
|
|
if finish == 0 {
|
|
finish = now.UnixMilli()
|
|
}
|
|
elapsed := addSpan(v.StartMS, finish, false)
|
|
if elapsed == 0 {
|
|
continue
|
|
}
|
|
out.Sessions = append(out.Sessions, v)
|
|
index, ok := byTask[v.TaskUUID]
|
|
if !ok {
|
|
index = len(out.Tasks)
|
|
byTask[v.TaskUUID] = index
|
|
out.Tasks = append(out.Tasks, TaskReportItem{UUID: v.TaskUUID, Title: title, ProjectUUID: project})
|
|
}
|
|
out.Tasks[index].WorkMS += elapsed
|
|
}
|
|
err = rows.Err()
|
|
rows.Close()
|
|
if err != nil {
|
|
return out, err
|
|
}
|
|
rows, err = s.DB.QueryContext(ctx, `SELECT start_ms,end_ms FROM organizer_focus_spans WHERE domain_uuid=? AND owner_uuid=? AND start_ms>=? AND start_ms<? AND end_ms>? AND phase='focus' ORDER BY start_ms,session_uuid,version LIMIT 10001`, domain, actor, start.Add(-180*time.Minute).UnixMilli(), end.UnixMilli(), start.UnixMilli())
|
|
if err != nil {
|
|
return out, err
|
|
}
|
|
defer rows.Close()
|
|
n = 0
|
|
for rows.Next() {
|
|
var a, b int64
|
|
if err = rows.Scan(&a, &b); err != nil {
|
|
return out, err
|
|
}
|
|
n++
|
|
if n > 10000 {
|
|
out.Partial = true
|
|
break
|
|
}
|
|
addSpan(a, b, true)
|
|
}
|
|
return out, rows.Err()
|
|
}
|