Как прочитать 4 запроса из Batch?

Чтение результатов из Batch-запросов в Go

Для чтения результатов 4 запросов из Batch (пакетного запроса) в Go существует несколько подходов в зависимости от используемой библиотеки и контекста. Основные сценарии включают работу с базами данных (SQL), NoSQL хранилищами, HTTP-запросами или кастомными batch-системами. Рассмотрим наиболее распространенные случаи.

Основные подходы к обработке Batch-запросов

1. Пакетные запросы в SQL (database/sql)

В стандартной библиотеке database/sql можно использовать подготовленные запросы с несколькими наборами параметров:

package main

import (
    "database/sql"
    "fmt"
    "log"
)

func processBatchQueries(db *sql.DB, ids []int64) error {
    // Создаем базовый запрос
    query := "SELECT id, name FROM users WHERE id = ?"
    
    // Подготавливаем statement для многократного использования
    stmt, err := db.Prepare(query)
    if err != nil {
        return fmt.Errorf("prepare statement failed: %w", err)
    }
    defer stmt.Close()
    
    // Выполняем 4 запроса
    var results []User
    for i := 0; i < 4 && i < len(ids); i++ {
        var user User
        err := stmt.QueryRow(ids[i]).Scan(&user.ID, &user.Name)
        if err != nil {
            log.Printf("Query %d failed: %v", i, err)
            continue
        }
        results = append(results, user)
    }
    
    return nil
}

type User struct {
    ID   int64
    Name string
}

2. Использование транзакций для пакетных операций

Для атомарного выполнения нескольких запросов применяются транзакции:

func executeBatchInTransaction(db *sql.DB, queries []string) error {
    tx, err := db.Begin()
    if err != nil {
        return fmt.Errorf("begin transaction failed: %w", err)
    }
    
    // Выполняем до 4 запросов в транзакции
    for i := 0; i < 4 && i < len(queries); i++ {
        _, err := tx.Exec(queries[i])
        if err != nil {
            tx.Rollback()
            return fmt.Errorf("query %d failed: %w", i, err)
        }
    }
    
    return tx.Commit()
}

3. Параллельное выполнение с помощью горутин

Для одновременного чтения 4 запросов используем горутины и каналы:

func readFourQueriesConcurrently(db *sql.DB, queries []string) ([]Result, error) {
    results := make([]Result, 4)
    errChan := make(chan error, 4)
    doneChan := make(chan bool, 4)
    
    // Запускаем 4 горутины для параллельного выполнения
    for i := 0; i < 4; i++ {
        go func(idx int) {
            defer func() { doneChan <- true }()
            
            var result Result
            err := db.QueryRow(queries[idx]).Scan(&result.Value)
            if err != nil {
                errChan <- fmt.Errorf("query %d: %w", idx, err)
                return
            }
            results[idx] = result
        }(i)
    }
    
    // Ждем завершения всех горутин
    for i := 0; i < 4; i++ {
        <-doneChan
    }
    
    // Проверяем ошибки
    select {
    case err := <-errChan:
        return nil, err
    default:
        return results, nil
    }
}

4. Использование sync.WaitGroup для синхронизации

Более структурированный подход с sync.WaitGroup:

import "sync"

func readBatchWithWaitGroup(db *sql.DB, queries []string) ([]Result, error) {
    var wg sync.WaitGroup
    results := make([]Result, 4)
    errors := make([]error, 4)
    var mu sync.Mutex
    
    for i := 0; i < 4; i++ {
        wg.Add(1)
        
        go func(idx int) {
            defer wg.Done()
            
            var result Result
            err := db.QueryRow(queries[idx]).Scan(&result.Value)
            
            mu.Lock()
            if err != nil {
                errors[idx] = err
            } else {
                results[idx] = result
            }
            mu.Unlock()
        }(i)
    }
    
    wg.Wait()
    
    // Проверяем наличие ошибок
    for _, err := range errors {
        if err != nil {
            return nil, fmt.Errorf("batch query failed: %w", err)
        }
    }
    
    return results, nil
}

Ключевые аспекты обработки Batch-запросов

1. Управление соединениями:

   • Используйте пул соединений для эффективного управления ресурсами
   • Настройте SetMaxOpenConns и SetMaxIdleConns в соответствии с нагрузкой

2. Обработка ошибок:

   • Всегда проверяйте ошибки после каждого запроса
   • Реализуйте стратегии повторных попыток (retry) для устойчивости

3. Контексты для контроля времени выполнения:

   ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
   defer cancel()
   
   // Использование контекста в запросах
   rows, err := db.QueryContext(ctx, "SELECT ...")
   

4. Лимитирование (rate limiting):

   • Используйте семафоры или пулы воркеров для контроля нагрузки

   sem := make(chan struct{}, 4) // Одновременно не более 4 запросов
   

Рекомендации по производительности

• Пакетные операции всегда эффективнее множества отдельных запросов
• Используйте PREPARE statement для повторяющихся запросов
• Рассмотрите использование хранимых процедур для сложных пакетных операций
• Для чтения больших объемов данных используйте Query вместо QueryRow с итерацией по rows.Next()

Заключение

Чтение 4 запросов из Batch в Go требует понимания:

• Механизмов параллельного выполнения (горутины, каналы, WaitGroup)
• Управления транзакциями для атомарности операций
• Правильной обработки ошибок и ресурсов
• Использования контекстов для контроля времени выполнения

Выбор подхода зависит от конкретных требований: нужна ли атомарность, важна ли скорость выполнения, требуется ли обработка ошибок для каждого запроса индивидуально. Для большинства сценариев оптимальным будет использование горутин с синхронизацией через WaitGroup и каналы для обработки ошибок.