Ошибка синтаксиса SQL

Проблема в том, что при создании таблицы вы используете рефлексию для получения тегов json и db_type из структуры UserDto. Если в структуре UserDto отсутствуют или некорректно указаны эти теги, то при генерации SQL-запроса получается некорректный синтаксис.

Например, если теги отсутствуют, то field.Tag.Get("json") и field.Tag.Get("db_type") вернут пустые строки. В результате ваш SQL-запрос будет выглядеть примерно так:

sql
CREATE TABLE users (, , , )

Это, естественно, приведет к ошибке синтаксиса.

Как исправить:

Убедитесь, что в структуре UserDto для каждого поля указаны корректные теги json и db_type. Пример:

go
type UserDto struct {
    Id        int       `json:"id" db_type:"SERIAL PRIMARY KEY"`
    Login     string    `json:"login" db_type:"VARCHAR(255)"`
    Pass      string    `json:"password" db_type:"VARCHAR(255)"`
    Role      string    `json:"role" db_type:"VARCHAR(50)"`
    Del       bool      `json:"del" db_type:"BOOLEAN"`
    DeletedAt time.Time `json:"deleted_at" db_type:"TIMESTAMP"`
}

После этого ваш код для создания таблицы сможет корректно сгенерировать SQL-запрос:

sql
CREATE TABLE users (id SERIAL PRIMARY KEY, login VARCHAR(255), password VARCHAR(255), role VARCHAR(50), del BOOLEAN, deleted_at TIMESTAMP)

Причина ошибки:

• Отсутствие или неправильное использование тегов json и db_type в структуре UserDto.
• В результате генерируется некорректный SQL-запрос, что приводит к ошибке синтаксиса на позиции, где ожидается корректное имя поля или тип данных.

Рекомендации:

• Всегда проверяйте, что все необходимые теги присутствуют и правильно заполнены.
• Для отладки можно вывести сгенерированный SQL-запрос перед его выполнением, чтобы убедиться в его корректности.

Проблема связана с тем, что некоторые имена полей, такие как password, могут быть зарезервированными словами в SQL (особенно в PostgreSQL). Когда вы генерируете SQL-запрос без экранирования имен полей, это может привести к ошибке синтаксиса.

Ошибка:

text
ошибка синтаксиса (примерное положение: ",")
position 68

Если подсчитать позиции, то 68-я позиция попадает на слово password в вашем сгенерированном SQL-запросе.

Решение:

Экранируйте имена полей, обернув их в двойные кавычки. Это позволит избежать конфликтов с зарезервированными словами и обеспечит корректный синтаксис SQL-запроса.

Как исправить код:

Измените часть кода, где вы формируете список полей, следующим образом:

go
for i := 0; i < reflectTable.NumField(); i++ {
    field := reflectTable.Field(i)
    jsonTag := field.Tag.Get("json")
    dbType := field.Tag.Get("db_type")
    // Экранируем имя поля двойными кавычками
    fields = append(fields, fmt.Sprintf(`"%s" %s`, jsonTag, dbType))
}

Таким образом, ваши имена полей будут выглядеть как "id", "login", "password" и т.д.

Пример сгенерированного SQL-запроса:

sql
CREATE TABLE users ("id" SERIAL PRIMARY KEY, "login" VARCHAR(100), "password" VARCHAR(100), "role" VARCHAR(100), "del" BOOLEAN, "deleted_at" TIMESTAMP)

Почему это работает:

• Экранирование имен полей двойными кавычками позволяет использовать любые идентификаторы, даже если они совпадают с зарезервированными словами.
• Это стандартная практика при работе с SQL, чтобы избежать конфликтов и обеспечить корректность запросов.

Дополнительные рекомендации:

• Всегда экранируйте имена таблиц и полей, если есть вероятность совпадения с зарезервированными словами.

• Для отладки выводите сгенерированный SQL-запрос перед его выполнением:

  go
  log.Printf("Создаем таблицу с запросом: %s", result)

• Убедитесь, что у вас установлены все необходимые права доступа для создания таблиц в базе данных.

Полный исправленный код функции NewUserStorage:

go
func NewUserStorage() *UserStorage {
    driver, name, pass, dbName := os.Getenv("DB_DRIVER"), os.Getenv("DB_NAME"), os.Getenv("DB_PASSWORD"), os.Getenv("DB_NAME")

    db, err := sql.Open(driver, fmt.Sprintf("user=%s password=%s dbname=%s sslmode=disable", name, pass, dbName))
    if err != nil {
        log.Fatal(fmt.Sprintf("Database connection failed: %s", err))
    }

    // Создаем таблицу в БД, если её нет
    user := models.UserDto{}
    reflectTable := reflect.TypeOf(user)

    var fields []string
    for i := 0; i < reflectTable.NumField(); i++ {
        field := reflectTable.Field(i)
        jsonTag := field.Tag.Get("json")
        dbType := field.Tag.Get("db_type")
        // Экранируем имя поля двойными кавычками
        fields = append(fields, fmt.Sprintf(`"%s" %s`, jsonTag, dbType))
    }

    result := fmt.Sprintf("CREATE TABLE IF NOT EXISTS users (%s)", strings.Join(fields, ", "))
    _, err = db.Exec(result)
    if err != nil {
        log.Printf("Ошибка при создании таблицы users: %s", err)
    } else {
        log.Print("Таблица users успешно создана или уже существует")
    }

    return &UserStorage{db: db}
}

Объяснение изменений:

• Добавили экранирование имен полей с помощью fmt.Sprintf и двойных кавычек.
• Добавили проверку IF NOT EXISTS в SQL-запросе CREATE TABLE, чтобы избежать ошибки, если таблица уже существует.
• Улучшили обработку ошибок и сообщения логирования для большей информативности.

Вывод:

Экранирование имен полей решит проблему синтаксиса и позволит успешно создать таблицу в базе данных.

Ошибка с кодом 42601 в PostgreSQL означает синтаксическую ошибку в SQL-запросе. Давайте попробуем найти и исправить эту ошибку.

1. Вывод сгенерированного SQL-запроса

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

go
log.Printf("Создаем таблицу с запросом: %s", result)

Это поможет нам увидеть, что именно генерируется и где может быть ошибка.

2. Возможные причины ошибки

• Экранирование имени таблицы: Возможно, проблема возникает из-за имени таблицы users, которое может конфликтовать с системными таблицами или зарезервированными словами. Экранируйте имя таблицы двойными кавычками:

  go
  result := fmt.Sprintf(`CREATE TABLE IF NOT EXISTS "%s" (%s)`, "users", strings.Join(fields, ", "))

• Тип данных для time.Time: Ваша структура UserDto содержит поле DeletedAt типа time.Time с типом базы данных TIMESTAMP. При использовании time.Time необходимо убедиться, что значение по умолчанию корректно, или заменить тип на NULLABLE TIMESTAMP.

• Отсутствие запятой или неправильный синтаксис: Возможно, где-то в сгенерированном SQL-запросе пропущена запятая или есть лишний символ.

3. Проверка типов данных

Убедитесь, что все типы данных соответствуют тем, которые поддерживает PostgreSQL. Например, для автогенерируемого первичного ключа обычно используется SERIAL или BIGSERIAL. Однако начиная с PostgreSQL 10 рекомендуется использовать GENERATED ALWAYS AS IDENTITY.

Обновите тип данных для поля Id:

go
Id int `json:"id" db_type:"INTEGER PRIMARY KEY GENERATED ALWAYS AS IDENTITY"`

4. Полный пример исправленного кода

Вот обновленная функция NewUserStorage с учетом вышеизложенного:

go
func NewUserStorage() *UserStorage {
    driver, name, pass, dbName := os.Getenv("DB_DRIVER"), os.Getenv("DB_NAME"), os.Getenv("DB_PASSWORD"), os.Getenv("DB_NAME")

    db, err := sql.Open(driver, fmt.Sprintf("user=%s password=%s dbname=%s sslmode=disable", name, pass, dbName))
    if err != nil {
        log.Fatal(fmt.Sprintf("Database connection failed: %s", err))
    }

    // Создаем таблицу в БД, если её нет
    user := models.UserDto{}
    reflectTable := reflect.TypeOf(user)

    var fields []string
    for i := 0; i < reflectTable.NumField(); i++ {
        field := reflectTable.Field(i)
        jsonTag := field.Tag.Get("json")
        dbType := field.Tag.Get("db_type")
        // Экранируем имя поля двойными кавычками
        fields = append(fields, fmt.Sprintf(`"%s" %s`, jsonTag, dbType))
    }

    // Экранируем имя таблицы и добавляем IF NOT EXISTS
    result := fmt.Sprintf(`CREATE TABLE IF NOT EXISTS "%s" (%s)`, "users", strings.Join(fields, ", "))
    
    // Выводим сгенерированный SQL-запрос
    log.Printf("Создаем таблицу с запросом: %s", result)
    
    _, err = db.Exec(result)
    if err != nil {
        log.Printf("Ошибка при создании таблицы users: %s", err)
    } else {
        log.Print("Таблица users успешно создана или уже существует")
    }

    return &UserStorage{db: db}
}

5. Проверка выполнения запроса

После внесения изменений запустите код и внимательно посмотрите на вывод сгенерированного SQL-запроса. Если ошибка все еще возникает, обратите внимание на позицию ошибки, которую сообщает PostgreSQL, и сопоставьте ее с позицией в SQL-запросе.

6. Пример возможного SQL-запроса

После внесенных изменений SQL-запрос должен выглядеть примерно так:

sql
CREATE TABLE IF NOT EXISTS "users" (
    "id" INTEGER PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
    "login" VARCHAR(100),
    "password" VARCHAR(100),
    "role" VARCHAR(100),
    "del" BOOLEAN,
    "deleted_at" TIMESTAMP
)

7. Дополнительные советы

• Проверка зарезервированных слов: Убедитесь, что ни названия полей, ни названия таблиц не совпадают с зарезервированными словами PostgreSQL. Если совпадают, экранирование должно решить проблему.

• Соответствие типов данных: Убедитесь, что типы данных в тегах db_type соответствуют тем, которые ожидает PostgreSQL.

• Правильность синтаксиса: Проверьте, нет ли лишних или недостающих запятых, скобок или других символов.

8. Если проблема сохраняется

Если после всех этих изменений ошибка все еще возникает, пожалуйста, предоставьте:

• Точный текст ошибки, включая позицию и описание.
• Сгенерированный SQL-запрос, который выведется с помощью log.Printf.
• Любые дополнительные сообщения об ошибках или предупреждениях.

Это позволит более точно определить проблему и предложить конкретное решение.

9. Пример проверки SQL-запроса в консоли PostgreSQL

Вы можете взять сгенерированный SQL-запрос и попробовать выполнить его напрямую в консоли PostgreSQL или через инструмент управления базой данных (например, pgAdmin). Это поможет определить, является ли проблема с синтаксисом или с кодом Go.

Вывод

Ошибка с кодом 42601 указывает на синтаксическую ошибку в SQL-запросе. Экранирование имен таблиц и полей, проверка соответствия типов данных и вывод сгенерированного SQL-запроса для отладки должны помочь решить проблему.

Проблема связана с тем, что по умолчанию Squirrel использует знак вопроса ? в качестве плейсхолдера для параметров в SQL-запросах. Однако PostgreSQL ожидает плейсхолдеры в формате $1, $2 и т.д. Поэтому, при использовании Squirrel с PostgreSQL, необходимо явно установить формат плейсхолдеров на squirrel.Dollar.

В вашем коде вы не устанавливаете формат плейсхолдеров, поэтому Squirrel генерирует SQL-запросы с ?, что приводит к ошибке синтаксиса (код ошибки 42601).

Как исправить:

1. Установите формат плейсхолдеров для PostgreSQL:

   При построении запросов с помощью Squirrel добавьте метод PlaceholderFormat(squirrel.Dollar).

2. Используйте общий билдер запросов для хранилища:

   Создайте заранее настроенный билдер запросов для вашего UserStorage.

Исправленный код:

go
package repository

import (
	"context"
	"database/sql"
	"fmt"
	"github.com/Masterminds/squirrel"
	_ "github.com/lib/pq"
	"log"
	"os"
	"reflect"
	"repository/internal/models"
	"strings"
)

type UserStorage struct {
	db           *sql.DB
	queryBuilder squirrel.StatementBuilderType
}

func NewUserStorage() *UserStorage {
	driver, name, pass, dbName := os.Getenv("DB_DRIVER"), os.Getenv("DB_USER"), os.Getenv("DB_PASSWORD"), os.Getenv("DB_NAME")

	connStr := fmt.Sprintf("user=%s password=%s dbname=%s sslmode=disable", name, pass, dbName)
	db, err := sql.Open(driver, connStr)
	if err != nil {
		log.Fatal(fmt.Sprintf("Не удалось подключиться к базе данных: %s", err))
	}

	// Создаем таблицу в БД, если её нет
	user := models.UserDto{}
	reflectTable := reflect.TypeOf(user)

	var fields []string
	for i := 0; i < reflectTable.NumField(); i++ {
		field := reflectTable.Field(i)
		jsonTag := field.Tag.Get("json")
		dbType := field.Tag.Get("db_type")
		fields = append(fields, fmt.Sprintf(`"%s" %s`, jsonTag, dbType))
	}

	result := fmt.Sprintf("CREATE TABLE IF NOT EXISTS users (%s)", strings.Join(fields, ", "))
	_, err = db.Exec(result)
	if err != nil {
		log.Printf("Ошибка при создании таблицы users: %s", err)
	} else {
		log.Print("Таблица users успешно создана или уже существует")
	}

	// Настраиваем билдер запросов для PostgreSQL
	queryBuilder := squirrel.StatementBuilder.PlaceholderFormat(squirrel.Dollar)

	return &UserStorage{
		db:           db,
		queryBuilder: queryBuilder,
	}
}

func (us *UserStorage) Create(ctx context.Context, user models.UserDto) error {
	// Используем настроенный билдер запросов
	query := us.queryBuilder.Insert("users").
		Columns("id", "login", "password", "role", "del").
		Values(user.Id, user.Login, user.Pass, user.Role, user.Del)

	// Генерируем SQL-запрос и аргументы
	sqlStr, args, err := query.ToSql()
	if err != nil {
		return fmt.Errorf("Ошибка создания пользователя: %s", err)
	}

	// Выполняем запрос
	_, err = us.db.Exec(sqlStr, args...)
	if err != nil {
		return fmt.Errorf("Ошибка создания пользователя: %s", err)
	}
	log.Print("Успешное создание пользователя")
	return nil
}

// Остальные методы остаются без изменений
func (us *UserStorage) GetByID(ctx context.Context, id string) (UserStorage, error) {
	//TODO implement me
	panic("implement me")
}

func (us *UserStorage) Update(ctx context.Context, user UserStorage) error {
	//TODO implement me
	panic("implement me")
}

func (us *UserStorage) Delete(ctx context.Context, id string) error {
	//TODO implement me
	panic("implement me")
}

Объяснение изменений:

• Настройка плейсхолдеров для PostgreSQL:

  В NewUserStorage мы создаем queryBuilder, используя squirrel.StatementBuilder.PlaceholderFormat(squirrel.Dollar), и сохраняем его в структуре UserStorage.

• Использование queryBuilder в методе Create:

  При построении запроса в методе Create мы используем us.queryBuilder, что гарантирует использование правильного формата плейсхолдеров.

• Генерация SQL-запроса и аргументов:

  Метод ToSql() возвращает сгенерированный SQL-запрос и слайс аргументов. Это позволяет точно увидеть, какой запрос будет выполнен.

• Обработка ошибок:

  Мы используем fmt.Errorf для форматирования ошибок, что является более идиоматичным в Go.

Дополнительные рекомендации:

• Проверьте параметры подключения к базе данных:

  Убедитесь, что вы используете правильные переменные окружения для имени пользователя и базы данных (DB_USER, DB_PASSWORD, DB_NAME).

• Выводите сгенерированные SQL-запросы для отладки:

  Для проверки корректности можно добавить вывод сгенерированного SQL-запроса:

  go
  log.Printf("SQL Query: %s, Args: %v", sqlStr, args)

• Убедитесь, что типы данных соответствуют PostgreSQL:

  Проверьте, что типы данных в тегах db_type соответствуют типам PostgreSQL.

• Используйте транзакции при необходимости:

  Если вам нужно обеспечить атомарность операций, рассмотрите использование транзакций.

Заключение:

Проблема была в несовместимости плейсхолдеров, используемых Squirrel по умолчанию, с требованиями PostgreSQL. Установив формат плейсхолдеров на squirrel.Dollar, вы сможете успешно выполнять запросы к PostgreSQL без ошибок синтаксиса.

Если после внесения изменений ошибка все еще возникает, пожалуйста, предоставьте текст ошибки и сгенерированный SQL-запрос для более детального анализа.

Проблема возникает из-за несоответствия между количеством выбранных столбцов в вашем SQL-запросе и количеством аргументов, в которые вы пытаетесь их сохранить с помощью метода Scan.

Ошибка:

sql: expected 1 destination arguments in Scan, not 6

Это означает, что запрос возвращает только один столбец, а вы пытаетесь считать данные в шесть переменных.

Причина ошибки:

В вашем SQL-запросе вы выбираете только столбец "id":

go
sq, args, err := us.builder.Select("id").From(us.TableName()).Where(squirrel.Eq{"id": id}).ToSql()

Однако при считывании результата вы пытаетесь заполнить все поля структуры UserDto:

go
scanErr := row.Scan(&user.Id, &user.Login, &user.Pass, &user.Role, &user.Del, &user.DeletedAt)

Поскольку запрос возвращает только один столбец ("id"), метод Scan ожидает только один аргумент для сохранения результата.

Как исправить:

1. Выберите все необходимые столбцы в запросе.

   Измените метод Select, чтобы он выбирал все поля, которые вам нужны:

   go
   sq, args, err := us.builder.
       Select("id", "login", "password", "role", "del", "deleted_at").
       From(us.TableName()).
       Where(squirrel.Eq{"id": id}).
       ToSql()

   Или используйте Select("*"), если хотите выбрать все столбцы:

   go
   sq, args, err := us.builder.
       Select("*").
       From(us.TableName()).
       Where(squirrel.Eq{"id": id}).
       ToSql()

2. Используйте QueryRowContext для запроса одной строки.

   Поскольку вы ожидаете получить только одну запись по id, лучше использовать QueryRowContext вместо QueryContext и цикла for row.Next():

   go
   row := us.db.QueryRowContext(ctx, sq, args...)

3. Считывайте данные без цикла.

   Теперь вы можете сразу вызвать Scan на объекте row:

   go
   err = row.Scan(&user.Id, &user.Login, &user.Pass, &user.Role, &user.Del, &user.DeletedAt)
   if err != nil {
       return models.UserDto{}, fmt.Errorf("ошибка получения пользователя: %w", err)
   }

4. Возвращайте заполненную структуру UserDto.

   После успешного считывания данных верните пользователя и nil в качестве ошибки:

   go
   return user, nil

Исправленный код функции GetByID:

go
func (us *UserStorage) GetByID(ctx context.Context, id int) (models.UserDto, error) {
    // Выбираем все необходимые столбцы
    sq, args, err := us.builder.
        Select("id", "login", "password", "role", "del", "deleted_at").
        From(us.TableName()).
        Where(squirrel.Eq{"id": id}).
        ToSql()
    if err != nil {
        return models.UserDto{}, fmt.Errorf("ошибка формирования запроса: %w", err)
    }

    // Выполняем запрос и получаем одну строку
    row := us.db.QueryRowContext(ctx, sq, args...)

    var user models.UserDto
    // Считываем данные без цикла
    err = row.Scan(&user.Id, &user.Login, &user.Pass, &user.Role, &user.Del, &user.DeletedAt)
    if err != nil {
        if err == sql.ErrNoRows {
            return models.UserDto{}, fmt.Errorf("пользователь с id %d не найден", id)
        }
        return models.UserDto{}, fmt.Errorf("ошибка получения пользователя: %w", err)
    }

    return user, nil
}

Пояснения:

• Изменение метода Select: Теперь вы выбираете все столбцы, соответствующие полям в структуре UserDto. Это обеспечивает соответствие между количеством выбранных столбцов и количеством аргументов в Scan.

• Использование QueryRowContext: Этот метод удобен для получения одной строки из базы данных и упрощает код.

• Обработка ошибок: Добавлена проверка на sql.ErrNoRows, чтобы вернуть понятную ошибку, если пользователь не найден.

Дополнительные рекомендации:

• Проверьте соответствие имен столбцов и полей структуры:

  Убедитесь, что имена столбцов в базе данных соответствуют именам, которые вы используете в методе Select, и что порядок аргументов в Scan соответствует порядку столбцов в запросе.

• Используйте константы или методы для получения имени таблицы:

  Если метод us.TableName() возвращает имя таблицы, убедитесь, что он работает корректно.

• Логирование и отладка:

  Для отладки можно вывести сгенерированный SQL-запрос и аргументы:

  go
  log.Printf("SQL Query: %s, Args: %v", sq, args)

• Безопасность паролей:

  Помните, что хранить пароли в открытом виде небезопасно. Рекомендуется хранить хэшированные пароли и не возвращать их в ответах из функций, где это не требуется.

Заключение:

Ошибка связана с тем, что вы выбирали только один столбец ("id") в запросе, но пытались считать шесть значений. Исправив запрос и выбрав все необходимые столбцы, вы решите проблему.