Запись в базу данных

type Video struct {
    Id          string    // video_id
    Title       string    // title
    PublishTime time.Time // publish_time
    Tags        []string  // tags
    Views       int       // views
} 

func readVideoCSV(csvFile string) ([]Video, error) {
    // открываем csv файл
    file, err := os.Open(csvFile)
    if err != nil {
        return nil, err
    }
    defer file.Close()
    var videos []Video

    // определим индексы нужных полей
    const (
        Id          = 0 // video_id
        Title       = 2 // title
        PublishTime = 5 // publish_time
        Tags        = 6 // tags
        Views       = 7 // views
    )

    // конструируем Reader из пакета encoding/csv
    // он умеет читать строки csv-файла
    r := csv.NewReader(file)
    // пропустим первую строку с именами полей
    if _, err := r.Read(); err != nil {
        return nil, err
    }

    for {
        // csv.Reader за одну операцию Read() считывает одну csv-запись
        l, err := r.Read()
        if err == io.EOF {
            break
        }
        if err != nil {
            return nil, err
        }
        // инициализируем целевую структуру,
        // в которую будем делать разбор csv-записи
        v := Video{
            Id:    l[Id],
            Title: l[Title],
        }
        // парсинг строковых записей в типизированные поля структуры
        if v.PublishTime, err = time.Parse(time.RFC3339, l[PublishTime]); err != nil {
            return nil, err
        }
        tags := strings.Split(l[Tags], "|")
        for i, v := range tags {
            tags[i] = strings.Trim(v, `"`)
        }
        v.Tags = tags
        if v.Views, err = strconv.Atoi(l[Views]); err != nil {
            return nil, err
        }
        // добавляем полученную структуру в слайс
        videos = append(videos, v)
    }
    return videos, nil
} 

func insertVideos(ctx context.Context, db *sql.DB, videos []Video) error {
    // здесь будем вставлять записи в базу данных
    // ...
    return nil
}

func main() {
    // открываем соединение с БД
    db, err := sql.Open("sqlite", "newvideo.db")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()
    // читаем записи из файла в слайс []Video вспомогательной функцией
    videos, err := readVideoCSV("USvideos.csv")
    if err != nil {
        log.Fatal(err)
    }
    // записываем []Video в базу данных
    // тоже вспомогательной функцией
    err = insertVideos(context.Background(), db, videos)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Всего csv-записей %v\n", len(videos))
} 

(db *DB) ExecContext(ctx context.Context, query string, args ...any) (Result, error) 

type Result interface {
    LastInsertId() (int64, error)
    RowsAffected() (int64, error)
} 

for _, v := range videos {
    // в этом случае возвращаемое значение не несёт полезной информации,
    // поэтому его можно игнорировать
    _, err := db.ExecContext(ctx,
        "INSERT INTO videos (video_id, title, publish_time, tags, views)"+
            " VALUES(?,?,?,?,?)", v.Id, v.Title, v.PublishTime, 
            strings.Join(v.Tags, `|`), v.Views)
    if err != nil {
        return err
    }
} 

start := time.Now()
err = insertVideos(context.Background(), db, videos)
if err != nil {
    log.Fatal(err)
}
fmt.Println(time.Since(start)) 

func (db *DB) Begin() (*Tx, error)
func (db *DB) BeginTx(ctx context.Context, opts *TxOptions) (*Tx, error) 

func insertVideos(ctx context.Context, db *sql.DB, videos []Video) error {
    // начинаем транзакцию
    tx, err := db.Begin()
    if err != nil {
        return err
    }
    for _, v := range videos {
        // все изменения записываются в транзакцию
        _, err := tx.ExecContext(ctx, 
            "INSERT INTO videos (video_id, title, publish_time, tags, views)"+
            " VALUES(?,?,?,?,?)", v.Id, v.Title, v.PublishTime,
            strings.Join(v.Tags, `|`), v.Views)
        if err != nil {
            // если ошибка, то откатываем изменения
            tx.Rollback()
            return err
        }
    }
    // завершаем транзакцию
    return tx.Commit()
} 

func (db *DB) PrepareContext(ctx context.Context, query string) (*Stmt, error)
func (db *DB) Prepare(query string) (*Stmt, error) 

row := db.QueryRowContext(ctx, 
            "SELECT description FROM videos WHERE video_id = ?", id)

// пример с использованием PrepareContext
stmt, err := db.PrepareContext(ctx, "SELECT description FROM videos WHERE video_id = ?")
// не забывайте закрывать запрос
defer stmt.Close()
// сам запрос не указывается, передаются только параметры
row := stmt.QueryRowContext(ctx, id) 

// query_test.go
package main

import (
    "database/sql"
    "log"
    "testing"

    _ "modernc.org/sqlite"
)

func BenchmarkQuery(b *testing.B) {
    db, err := sql.Open("sqlite", "newvideo.db")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        db.QueryRow("SELECT title, views FROM videos WHERE video_id = ?", "R39-E3uG5J0")
    }
} 

_, err = db.ExecContext(ctx, "CREATE INDEX video_id ON videos (video_id)")
if err != nil {
    log.Fatal(err)
} 

package main

import (
    "context"
    "database/sql"
    "fmt"
    "log"
    "strings"

    _ "modernc.org/sqlite"
)

type TagVideo struct {
    Tags string
}

func getList(ctx context.Context, db *sql.DB) (videos []TagVideo, err error) {
    /* 1. Выберите список роликов, у которых в тегах есть слово best
       2. Получите теги в структуру TagVideo
       3. Добавьте TagVideo в videos
       4. Повторите пункты 2-3 для каждого найденного элемента
    */
}

func main() {
    // открываем соединение с БД
    db, err := sql.Open("sqlite", "newvideo.db")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    ctx := context.Background()

    videos, err := getList(ctx, db)
    if err != nil {
        log.Fatal(err)
    }

    var updates int64 // подсчитаем количество изменённых записей
    for _, v := range videos {
        var tags []string
        // удаляем лишние теги
        for _, tag := range strings.Split(v.Tags, `|`) {
            if !strings.Contains(strings.ToLower(tag), "best") {
                tags = append(tags, tag)
            }
        }
        res, err := db.ExecContext(ctx,
            "UPDATE videos SET tags = ? WHERE tags = ?",
            strings.Join(tags, "|"), v.Tags)
        if err != nil {
            log.Fatal(err)
        }
        // посмотрим, сколько записей было обновлено
        if upd, err := res.RowsAffected(); err == nil {
            updates += upd
        }
    }
    fmt.Println(updates)
} 

_, err := db.ExecContext(сtx, "DELETE FROM videos WHERE publish_time" +
                " BETWEEN ? AND ? AND views < ?", fromDate,
                toDate, viewsLimit) 

func Named(name string, value interface{}) NamedArg 

_, err := db.ExecContext(сtx, "DELETE FROM videos WHERE publish_time" +
                " BETWEEN @start AND @end AND views < @views",
                sql.Named("end", toDate),
                sql.Named("start", fromDate),
                sql.Named("views", viewsLimit),
) 

func (db *DB) SetMaxOpenConns(n int)
func (db *DB) SetMaxIdleConns(n int)
func (db *DB) SetConnMaxIdleTime(d time.Duration)
func (db *DB) SetConnMaxLifetime(d time.Duration) 

package main

import (
    "context"
    "fmt"
    "log"
    "strings"

    "github.com/jmoiron/sqlx"
    _ "modernc.org/sqlite"
)

type TagVideo struct {
    Tags string
}

func getList(ctx context.Context, db *sqlx.DB) (videos []TagVideo, err error) {
    sqlSelect := `SELECT tags FROM videos 
                    WHERE tags LIKE '%worst%' GROUP BY tags`
    err = db.SelectContext(ctx, &videos, sqlSelect)
    return
}

func main() {
    db := sqlx.MustOpen("sqlite", "newvideo.db")
    defer db.Close()

    ctx := context.Background()
    videos, err := getList(ctx, db)
    if err != nil {
        log.Fatal(err)
    }

    var updates int64
    sqlUpdate := "UPDATE videos SET tags = ? WHERE tags = ?"

    for _, v := range videos {
        var tags []string
        // удаляем лишние теги
        for _, tag := range strings.Split(v.Tags, `|`) {
            if !strings.Contains(strings.ToLower(tag), "worst") {
                tags = append(tags, tag)
            }
        }

        res := db.MustExecContext(ctx, sqlUpdate, strings.Join(tags, `|`), v.Tags)
        if upd, err := res.RowsAffected(); err == nil {
            updates += upd
        }
    }
    fmt.Println(updates)
} 

package pg

import (
    "context"
    "database/sql"
    "time"

    "github.com/bluegopher/alice-skill/internal/store"
)

// Store реализует интерфейс store.Store и позволяет взаимодействовать с СУБД PostgreSQL
type Store struct {
    // Поле conn содержит объект соединения с СУБД
    conn *sql.DB
}

// NewStore возвращает новый экземпляр PostgreSQL хранилища
func NewStore(conn *sql.DB) *Store {
    return &Store{conn: conn}
}

// Bootstrap подготавливает БД к работе, создавая необходимые таблицы и индексы
func (s Store) Bootstrap(ctx context.Context) error {
    // запускаем транзакцию
    tx, err := s.conn.BeginTx(ctx, nil)
    if err != nil {
        return err
    }

    // в случае неуспешного коммита все изменения транзакции будут отменены
    defer tx.Rollback()

    // создаём таблицу пользователей и необходимые индексы
    tx.ExecContext(ctx, `
        CREATE TABLE users (
            id varchar(128) PRIMARY KEY,
            username varchar(128)
        )
    `)
    tx.ExecContext(ctx, `CREATE UNIQUE INDEX sender_idx ON users (username)`)

    // создаём таблицу сообщений и необходимые индексы
    tx.ExecContext(ctx, `
        CREATE TABLE messages (
            id serial PRIMARY KEY,
            sender varchar(128),
            recepient varchar(128),
            payload text,
            sent_at timestamp with time zone,
            read_at timestamp with time zone DEFAULT NULL
        )
    `)
    tx.ExecContext(ctx, `CREATE INDEX recepient_idx ON messages (recepient)`)

    // коммитим транзакцию
    return tx.Commit()
}

func (s Store) FindRecepient(ctx context.Context, username string) (userID string, err error) {
    // запрашиваем внутренний идентификатор пользователя по его имени
    row := s.conn.QueryRowContext(ctx, `SELECT id FROM users WHERE username = $1`, username)
    err = row.Scan(&userID)
    return
}

func (s Store) ListMessages(ctx context.Context, userID string) ([]store.Message, error) {
    // запрашиваем данные обо всех сообщениях пользователя, без самого текста
    rows, err := s.conn.QueryContext(ctx, `
        SELECT
            m.id,
            u.username AS sender,
            m.sent_at
        FROM messages m
        JOIN users u ON m.sender = u.id
        WHERE
            m.recepient = $1
    `, userID)

    if err != nil {
        return nil, err
    }
    // не забываем закрыть курсор после завершения работы с данными
    defer rows.Close()

    // считываем записи в слайс сообщений
    var messages []store.Message
    for rows.Next() {
        var m store.Message
        if err := rows.Scan(&m.ID, &m.Sender, &m.Time); err != nil {
            return nil, err
        }
        messages = append(messages, m)
    }

    // необходимо проверить ошибки уровня курсора
    if err := rows.Err(); err != nil {
        return nil, err
    }

    return messages, nil
}

func (s Store) GetMessage(ctx context.Context, id int64) (*store.Message, error) {
    // запрашиваем сообщение по внутреннему идентификатору
    row := s.conn.QueryRowContext(ctx, `
        SELECT
            m.id,
            u.username AS sender,
            m.payload,
            m.sent_at
        FROM messages m
        JOIN users u ON m.sender = u.id
        WHERE
            m.id = $1
    `,
        id,
    )

    // считываем значения из записи БД в соответствующие поля структуры
    var msg store.Message
    err := row.Scan(&msg.ID, &msg.Sender, &msg.Payload, &msg.Time)
    if err != nil {
        return nil, err
    }
    return &msg, nil
}

func (s Store) SaveMessage(ctx context.Context, userID string, msg store.Message) error {
    // добавляем новое сообщение в БД
    _, err := s.conn.ExecContext(ctx, `
        INSERT INTO messages
        (sender, recepient, payload, sent_at)
        VALUES
        ($1, $2, $3, $4);
    `, msg.Sender, userID, msg.Payload, time.Now())

    return err
}
 

package main

import (
    "flag"
    "os"
)

var (
    flagRunAddr  string
    flagLogLevel string
    // переменная будет содержать параметры соединения с СУБД
    flagDatabaseURI string
)

func parseFlags() {
    flag.StringVar(&flagRunAddr, "a", ":8080", "address and port to run server")
    flag.StringVar(&flagLogLevel, "l", "info", "log level")
    // обрабатываем аргумент -d
    flag.StringVar(&flagDatabaseURI, "d", "", "database URI")
    flag.Parse()

    if envRunAddr := os.Getenv("RUN_ADDR"); envRunAddr != "" {
        flagRunAddr = envRunAddr
    }
    if envLogLevel := os.Getenv("LOG_LEVEL"); envLogLevel != "" {
        flagLogLevel = envLogLevel
    }
    // обрабатываем переменную окружения DATABASE_URI
    if envDatabaseURI := os.Getenv("DATABASE_URI"); envDatabaseURI != "" {
        flagDatabaseURI = envDatabaseURI
    }
}
 

package main

import (
    "database/sql"
    "net/http"
    "strings"

    "github.com/bluegopher/alice-skill/internal/logger"
    "github.com/bluegopher/alice-skill/internal/store/pg"
    _ "github.com/jackc/pgx/v5/stdlib"
    "go.uber.org/zap"
)

func main() {
    parseFlags()

    if err := run(); err != nil {
        panic(err)
    }
}

func run() error {
    if err := logger.Initialize(flagLogLevel); err != nil {
        return err
    }

    // создаём соединение к СУБД PostgreSQL с помощью аргумента командной строки
    conn, err := sql.Open("pgx", flagDatabaseURI)
    if err != nil {
        return err
    }

    // создаём экземпляр приложения, передавая реализацию хранилища pg в качестве внешней зависимости
    appInstance := newApp(pg.NewStore(conn))

    logger.Log.Info("Running server", zap.String("address", flagRunAddr))
    // обернём хендлер webhook в middleware с логгированием и поддержкой gzip
    return http.ListenAndServe(flagRunAddr, logger.RequestLogger(gzipMiddleware(appInstance.webhook)))
}

...
 

func (a *app) webhook(w http.ResponseWriter, r *http.Request) {
    ctx := r.Context()

    if r.Method != http.MethodPost {
        logger.Log.Debug("got request with bad method", zap.String("method", r.Method))
        w.WriteHeader(http.StatusMethodNotAllowed)
        return
    }

    logger.Log.Debug("decoding request")
    var req models.Request
    dec := json.NewDecoder(r.Body)
    if err := dec.Decode(&req); err != nil {
        logger.Log.Debug("cannot decode request JSON body", zap.Error(err))
        w.WriteHeader(http.StatusInternalServerError)
        return
    }

    if req.Request.Type != models.TypeSimpleUtterance {
        logger.Log.Debug("unsupported request type", zap.String("type", req.Request.Type))
        w.WriteHeader(http.StatusUnprocessableEntity)
        return
    }

    // текст ответа навыка
    var text string

    switch true {
    // пользователь попросил отправить сообщение
    case strings.HasPrefix(req.Request.Command, "Отправь"):
        // гипотетическая функция parseSendCommand вычленит из запроса логин адресата и текст сообщения
        username, message := parseSendCommand(req.Request.Command)

        // найдём внутренний идентификатор адресата по его логину
        recepientID, err := a.store.FindRecepient(ctx, username)
        if err != nil {
            logger.Log.Debug("cannot find recepient by username", zap.String("username", username), zap.Error(err))
            w.WriteHeader(http.StatusInternalServerError)
            return
        }

        // сохраняем новое сообщение в СУБД, после успешного сохранения оно станет доступно для прослушивания получателем
        err = a.store.SaveMessage(ctx, recepientID, store.Message{
            Sender:  req.Session.User.UserID,
            Time:    time.Now(),
            Payload: message,
        })
        if err != nil {
            logger.Log.Debug("cannot save message", zap.String("recepient", recepientID), zap.Error(err))
            w.WriteHeader(http.StatusInternalServerError)
            return
        }

        // Оповестим отправителя об успешности операции
        text = "Сообщение успешно отправлено"

    // пользователь попросил прочитать сообщение
    case strings.HasPrefix(req.Request.Command, "Прочитай"):
        // гипотетическая функция parseSendCommand вычленит из запроса порядковый номер сообщения в списке доступных
        messageIndex := parseReadCommand(req.Request.Command)

        // получим список непрослушанных сообщений пользователя
        messages, err := a.store.ListMessages(ctx, req.Session.User.UserID)
        if err != nil {
            logger.Log.Debug("cannot load messages for user", zap.Error(err))
            w.WriteHeader(http.StatusInternalServerError)
            return
        }

        text = "Для вас нет новых сообщений."
        if len(messages) < messageIndex {
            // пользователь попросил прочитать сообщение, которого нет
            text = "Такого сообщения не существует."
        } else {
            // получим сообщение по идентификатору
            messageID := messages[messageIndex].ID
            message, err := a.store.GetMessage(ctx, messageID)
            if err != nil {
                logger.Log.Debug("cannot load message", zap.Int64("id", messageID), zap.Error(err))
                w.WriteHeader(http.StatusInternalServerError)
                return
            }

            // передадим текст сообщения в ответе
            text = fmt.Sprintf("Сообщение от %s, отправлено %s: %s", message.Sender, message.Time, message.Payload)
        }

    // если не поняли команду, просто скажем пользовутелю сколько у него новых сообщений
    default:
        messages, err := a.store.ListMessages(ctx, req.Session.User.UserID)
        if err != nil {
            logger.Log.Debug("cannot load messages for user", zap.Error(err))
            w.WriteHeader(http.StatusInternalServerError)
            return
        }

        text = "Для вас нет новых сообщений."
        if len(messages) > 0 {
            text = fmt.Sprintf("Для вас %d новых сообщений.", len(messages))
        }

        // первый запрос новой сессии
        if req.Session.New {
            // обработаем поле Timezone запроса
            tz, err := time.LoadLocation(req.Timezone)
            if err != nil {
                logger.Log.Debug("cannot parse timezone")
                w.WriteHeader(http.StatusBadRequest)
                return
            }

            // получим текущее время в часовом поясе пользователя
            now := time.Now().In(tz)
            hour, minute, _ := now.Clock()

            // формируем новый текст приветствия
            text = fmt.Sprintf("Точное время %d часов, %d минут. %s", hour, minute, text)
        }
    }

    // заполним модель ответа
    resp := models.Response{
        Response: models.ResponsePayload{
            Text: text, // Алиса проговорит текст
        },
        Version: "1.0",
    }

    w.Header().Set("Content-Type", "application/json")

    // сериализуем ответ сервера
    enc := json.NewEncoder(w)
    if err := enc.Encode(resp); err != nil {
        logger.Log.Debug("error encoding response", zap.Error(err))
        return
    }
    logger.Log.Debug("sending HTTP 200 response")
}