internal/storage/sqlite/objects.go - master - t3/s3-server

internal/storage/sqlite/objects.go
151 строка5 KB
Ivan
refactoring
16 июл 2026, 23:52
16 июл 2026, 23:5205c94e8
package sqlite

import (
	"context"
	"database/sql"
	"encoding/json"
	"errors"
	"fmt"
	"strings"
	"time"

	"gitverse.ru/t3/s3-server/internal/storage"
)

func (s *Storage) PutObjectMeta(ctx context.Context, meta storage.ObjectMeta) error {
	now := time.Now().Unix()

	diskIndexesJSON, err := json.Marshal(meta.DiskIndexes)
	if err != nil {
		return err
	}

	isComp := 0
	if meta.IsComposite {
		isComp = 1
	}

	_, err = s.db.ExecContext(ctx, `
        INSERT INTO objects (bucket, key, hash, size, content_type, disk_indexes, is_composite, created_at, updated_at, deleted, version_id)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 0, ?)
        ON CONFLICT(bucket, key) DO UPDATE SET
            hash = excluded.hash,
            size = excluded.size,
            content_type = excluded.content_type,
            disk_indexes = excluded.disk_indexes,
            is_composite = excluded.is_composite,
            updated_at = excluded.updated_at,
            deleted = 0,
            version_id = excluded.version_id
    `, meta.Bucket, meta.Key, meta.Hash, meta.Size, meta.ContentType, string(diskIndexesJSON), isComp, now, now, meta.VersionID)

	return err
}

func (s *Storage) GetObjectMeta(ctx context.Context, bucket, key string) (*storage.ObjectMeta, error) {
	var m storage.ObjectMeta
	var createdAt, updatedAt int64
	var deleted, isComp int
	var diskIndexesJSON string

	err := s.db.QueryRowContext(ctx, `
        SELECT bucket, key, hash, size, content_type, disk_indexes, is_composite, created_at, updated_at, deleted, version_id
        FROM objects 
        WHERE bucket = ? AND key = ? AND deleted = 0
    `, bucket, key).Scan(&m.Bucket, &m.Key, &m.Hash, &m.Size, &m.ContentType, &diskIndexesJSON, &isComp, &createdAt, &updatedAt, &deleted, &m.VersionID)

	if err != nil {
		if errors.Is(err, sql.ErrNoRows) {
			return nil, storage.ErrObjectNotFound
		}
		return nil, err
	}

	if diskIndexesJSON != "" {
		json.Unmarshal([]byte(diskIndexesJSON), &m.DiskIndexes)
	}
	m.IsComposite = isComp == 1
	m.CreatedAt = time.Unix(createdAt, 0)
	m.UpdatedAt = time.Unix(updatedAt, 0)
	m.Deleted = deleted == 1
	return &m, nil
}

func (s *Storage) ListObjects(ctx context.Context, bucket, prefix string) ([]storage.ObjectMeta, error) {
	escapedPrefix := strings.NewReplacer("%", "\\%", "_", "\\_").Replace(prefix)

	query := `
        SELECT bucket, key, hash, size, content_type, disk_indexes, is_composite, created_at, updated_at, deleted, version_id
        FROM objects 
        WHERE bucket = ? AND key LIKE ? ESCAPE '\' AND deleted = 0
        ORDER BY key ASC;
    `

	rows, err := s.db.QueryContext(ctx, query, bucket, escapedPrefix+"%")
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	var objects []storage.ObjectMeta
	for rows.Next() {
		var m storage.ObjectMeta
		var createdAt, updatedAt int64
		var deleted int
		var isComposite bool
		var diskIndexesJSON string
		if err := rows.Scan(&m.Bucket, &m.Key, &m.Hash, &m.Size, &m.ContentType, &diskIndexesJSON, &isComposite, &createdAt, &updatedAt, &deleted, &m.VersionID); err != nil {
			return nil, err
		}
		if err := json.Unmarshal([]byte(diskIndexesJSON), &m.DiskIndexes); err != nil {
			return nil, err
		}
		m.CreatedAt = time.Unix(createdAt, 0)
		m.UpdatedAt = time.Unix(updatedAt, 0)
		m.Deleted = deleted == 1
		m.IsComposite = isComposite
		objects = append(objects, m)
	}
	return objects, rows.Err()
}

func (s *Storage) DeleteObjectMeta(ctx context.Context, bucket, key string) (string, []int, bool, error) {
	var meta storage.ObjectMeta
	var diskIndexesJSON string
	var isComp int

	err := s.db.QueryRowContext(ctx, "SELECT hash, disk_indexes, is_composite FROM objects WHERE bucket = ? AND key = ? AND deleted = 0", bucket, key).
		Scan(&meta.Hash, &diskIndexesJSON, &isComp)
	if err != nil {
		if errors.Is(err, sql.ErrNoRows) {
			return "", nil, false, storage.ErrObjectNotFound
		}
		return "", nil, false, err
	}

	_, err = s.db.ExecContext(ctx, "UPDATE objects SET deleted = 1 WHERE bucket = ? AND key = ?", bucket, key)
	if err != nil {
		return "", nil, false, err
	}

	json.Unmarshal([]byte(diskIndexesJSON), &meta.DiskIndexes)
	return meta.Hash, meta.DiskIndexes, isComp == 1, nil
}

func (s *Storage) CountObjects(ctx context.Context, bucket string) (int64, error) {
	var count int64
	err := s.db.QueryRowContext(ctx,
		"SELECT COUNT(*) FROM objects WHERE bucket = ? AND deleted = 0",
		bucket,
	).Scan(&count)
	if err != nil {
		return 0, fmt.Errorf("failed to count objects: %w", err)
	}
	return count, nil
}

func (s *Storage) CountObjectsByHash(ctx context.Context, hash string) (int64, error) {
	var count int64
	err := s.db.QueryRowContext(ctx, "SELECT COUNT(*) FROM objects WHERE hash = ? AND deleted = 0", hash).Scan(&count)
	return count, err
}