Files
2026-11-15 05:47:14 +09:00

142 lines
3.0 KiB
Go

package store
import (
"context"
"time"
)
type RecentObject struct {
UUID string
Path string
Size int
UpdatedAt int64
documentHash string
}
func (s *Store) ListRecentObjects(
limit int,
) ([]RecentObject, error) {
domainUUID, err := s.defaultDomainUUID()
if err != nil {
return nil, err
}
return s.ListRecentObjectsInDomain(domainUUID, limit)
}
func (s *Store) ListRecentObjectsInDomain(
domainUUID string,
limit int,
) ([]RecentObject, error) {
if limit <= 0 || limit > 200 {
limit = 20
}
query := `
WITH latest AS (
SELECT
r.uuid,
r.object_uuid,
COALESCE(r.document_hash, '') AS document_hash,
r.created_at,
ROW_NUMBER() OVER (
PARTITION BY r.object_uuid
ORDER BY
COALESCE(r.created_at_ms, r.created_at * 1000) DESC,
r.rowid DESC
) AS rn
FROM revisions r
),
ranked_path AS (
SELECT
p.object_uuid,
p.path,
ROW_NUMBER() OVER (
PARTITION BY p.object_uuid
ORDER BY
COALESCE(p.is_primary, 0) DESC,
p.path ASC
) AS rn
FROM paths p
WHERE p.domain_uuid = ?
)
SELECT
o.uuid,
COALESCE(ranked_path.path, ''),
CASE
WHEN latest.document_hash <> '' THEN 0
ELSE COALESCE(LENGTH(r.body), 0)
END,
COALESCE(latest.created_at, o.created_at),
COALESCE(latest.document_hash, '')
FROM objects o
LEFT JOIN latest
ON latest.object_uuid = o.uuid
AND latest.rn = 1
LEFT JOIN revisions r
ON r.uuid = latest.uuid
JOIN ranked_path
ON ranked_path.object_uuid = o.uuid
AND ranked_path.rn = 1
ORDER BY
COALESCE(latest.created_at, o.created_at) DESC
LIMIT ?
`
if s.sqlBackend == storePostgreSQL {
query = `SELECT o.uuid,p.path,0,COALESCE(r.created_at,o.created_at),COALESCE(r.document_hash,'')
FROM (SELECT DISTINCT ON (object_uuid) object_uuid,path FROM paths WHERE domain_uuid=$1 ORDER BY object_uuid,is_primary DESC,path) p
JOIN objects o ON o.uuid=p.object_uuid
LEFT JOIN LATERAL (SELECT created_at,document_hash FROM revisions WHERE object_uuid=o.uuid ORDER BY created_at_ms DESC,uuid DESC LIMIT 1) r ON true
ORDER BY COALESCE(r.created_at,o.created_at) DESC,o.uuid LIMIT $2`
}
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()
rows, err := s.DB.QueryContext(ctx, query, domainUUID, limit)
if err != nil {
return nil, s.sqlError("recent objects", err)
}
defer rows.Close()
var out []RecentObject
for rows.Next() {
var ro RecentObject
err := rows.Scan(
&ro.UUID,
&ro.Path,
&ro.Size,
&ro.UpdatedAt,
&ro.documentHash,
)
if err != nil {
return nil, err
}
out = append(out, ro)
}
if err := rows.Close(); err != nil {
return nil, err
}
if err := rows.Err(); err != nil {
return nil, err
}
for i := range out {
if out[i].Size != 0 {
continue
}
if out[i].documentHash == "" {
continue
}
if s.DocumentRoot != "" {
if size, err := s.DocumentSize(out[i].documentHash); err == nil {
out[i].Size = int(size)
}
}
}
return out, nil
}