Naprawianie błędu Spring Boot: typy zmienne znakowe i typy Smallint nie mają operatora

Typowe pułapki związane z zapytaniami SQL w trybie Spring Boot: Niezgodność typów obsługi w PostgreSQL

Jako programiści wszyscy zetknęliśmy się z tajemniczymi komunikatami o błędach, które zdają się pojawiać znikąd. Jedna minuta, nasza Aplikacja Spring Boot działa płynnie; w następnej kolejności mamy do czynienia z błędem dotyczącym niezgodnych typów danych. 😅 Jest to zarówno frustrujące, jak i kłopotliwe, szczególnie w przypadku złożonych konfiguracji zapytań.

Ostatnio napotkałem błąd PostgreSQL w Spring Boot: „operator nie istnieje: zmienny znak = mała int.” Ten komunikat pojawił się podczas próby użycia pliku Zestaw wyliczeń w klauzuli IN zapytania SQL. Niezgodność między typem wyliczeniowym a typem kolumny bazy danych spowodowała nieoczekiwane problemy w pozornie prostym kodzie.

Chociaż kuszące jest zrzucanie winy na dziwactwa bazy danych lub Spring Boot, prawdziwy problem często leży w sposobie mapowania wyliczeń i typów baz danych. Wyliczenia Java, gdy są mapowane na bazy danych, wymagają specjalnej obsługi, szczególnie w przypadku PostgreSQL. Zrozumienie tych szczegółów może zaoszczędzić czas i zapobiec przyszłym problemom podczas pracy z wyliczeniami w Spring Boot.

W tym przewodniku wyjaśnię, jak zidentyfikowałem problem i znalazłem praktyczne rozwiązanie. Od mojego własnego debugowania po konkretne poprawki kodu — zyskasz narzędzia potrzebne do uniknięcia niezgodności typów w zapytaniach i zapewnienia bezproblemowych interakcji z bazą danych. 🔧

Rozwiązywanie niezgodności typów danych w Spring Boot z PostgreSQL

Podczas pracy z Wiosenne buty i PostgreSQL programiści często napotykają problemy z niedopasowaniem typów, szczególnie w przypadku wyliczeń. W tym przypadku pojawia się błąd „operator nie istnieje: znak zmienny = smallint”, ponieważ PostgreSQL nie może bezpośrednio zinterpretować wyliczenia Java jako typu SQL w zapytaniach natywnych. W tym przypadku jednostka SystemAccounts zawiera pole userCode reprezentowane przez wyliczenie AccountType, które odwzorowuje wartości takie jak „PERSONAL” lub „CORPORATE” w języku Java. Jednak podczas próby natywnego zapytania SQL z zestawem wyliczeń PostgreSQL nie może automatycznie dopasować typów wyliczeniowych, co powoduje ten błąd. Aby temu zaradzić, przed przekazaniem wyliczenia do zapytania należy koniecznie przekonwertować wyliczenie na ciąg znaków. 🎯

W dostarczonym rozwiązaniu zaczynamy od dostosowania mapowania wyliczeń w SystemAccounts za pomocą adnotacji @Enumerated(EnumType.STRING). To instruuje JPA, aby przechowywała każdy typ konta jako czytelny ciąg znaków, a nie numeryczną liczbę porządkową. To niewielka zmiana, ale upraszcza przyszłą obsługę danych, unikając wartości liczbowych, co utrudniłoby debugowanie w bazie danych. W naszym repozytorium możemy następnie użyć niestandardowej adnotacji @Query, aby określić logikę SQL. Jednakże, ponieważ PostgreSQL nadal potrzebuje wyliczeń jako ciągów znaków w zapytaniu, musimy przetworzyć wartości AccountType w formacie ciągu znaków przed ich przekazaniem.

Interfejs API CriteriaBuilder oferuje dynamiczne rozwiązanie tego problemu. Używając CriteriaBuilder, możemy uniknąć natywnego SQL, budując zapytania programowo w Javie. Takie podejście umożliwia nam dodawanie filtrów wyliczeniowych bez ręcznego pisania kodu SQL, co zmniejsza liczbę błędów SQL i ułatwia konserwację. W naszym skrypcie tworzymy listę warunków predykatu na podstawie wartości ciągu każdego wyliczenia, używając funkcji cb.equal() w celu dopasowania każdego typu konta w zestawie. Następnie cb.or() łączy te predykaty, umożliwiając wiele wartości w tym samym zapytaniu. Ta elastyczna konfiguracja dynamicznie zarządza konwersją wyliczenia na ciąg, minimalizując problemy ze zgodnością z PostgreSQL.

Wreszcie rozwiązanie obejmuje test jednostkowy w celu sprawdzenia zgodności. Używając JUnit, potwierdzamy, że każdy typ konta współpracuje z naszym zapytaniem, sprawdzając, czy pole userCode może przechowywać wartości „PERSONAL” lub „CORPORATE” i pobierać je bez błędów. Ta metoda testowa najpierw konfiguruje wymagane wartości typu konta i uruchamia zapytanie findAllByUserCodes() w celu sprawdzenia wyników. Dodanie kontroli AsserNotNull() i AssertTrue() gwarantuje, że nie napotkamy wartości null lub niepoprawnych, co gwarantuje, że nasze rozwiązanie skutecznie poradzi sobie ze wszystkimi przypadkami. Dzięki tej konfiguracji aplikacja jest lepiej przygotowana do obsługi zapytań wyliczeniowych w różnych warunkach produkcyjnych. 🧪

// Problem: PostgreSQL expects specific data types in queries.
// Solution: Convert enums to strings for query compatibility with PostgreSQL.
// This Spring Boot backend solution is clear, optimized, and includes type checks.

@Entity
@Table(name = "system_accounts")
@Getter
@Setter
public class SystemAccounts {
    @Id
    @Column(name = "id", nullable = false)
    private UUID id;
    @Column(name = "user_code")
    private String userCode;  // Store as String to avoid type mismatch
}

// Enumeration for AccountType
public enum AccountType {
    PERSONAL,
    CORPORATE
}

// Repository Query with Enum Handling
@Query(value = """
    SELECT sa.id FROM system_accounts sa
    WHERE sa.user_code IN :accountTypes""", nativeQuery = true)
Optional<List<SystemAccounts>> findAllByUserCodes(@Param("accountTypes") List<String> accountTypes);
// This query accepts a List of strings to avoid casting issues.

// Convert AccountType enums to Strings in Service
List<String> accountTypeStrings = accountTypes.stream()
    .map(Enum::name)
    .collect(Collectors.toList());

// Using CriteriaBuilder to dynamically handle enums in queries with automatic type checking.
// This approach uses Java’s Criteria API to avoid type mismatches directly in the code.

public List<SystemAccounts> findAllByUserCodes(Set<AccountType> accountTypes) {
    CriteriaBuilder cb = entityManager.getCriteriaBuilder();
    CriteriaQuery<SystemAccounts> query = cb.createQuery(SystemAccounts.class);
    Root<SystemAccounts> root = query.from(SystemAccounts.class);
    Path<String> userCodePath = root.get("userCode");
    List<Predicate> predicates = new ArrayList<>();

    // Add predicates for enum values, converting to String for matching
    for (AccountType type : accountTypes) {
        predicates.add(cb.equal(userCodePath, type.name()));
    }

    query.select(root)
         .where(cb.or(predicates.toArray(new Predicate[0])));
    return entityManager.createQuery(query).getResultList();
}

// This JUnit test ensures both solutions handle enums correctly with PostgreSQL.
// Tests database retrieval for both AccountType values: PERSONAL and CORPORATE.

@SpringBootTest
public class SystemAccountsRepositoryTest {
    @Autowired
    private SystemAccountsRepository repository;

    @Test
    public void testFindAllByUserCodes() {
        Set<AccountType> accountTypes = Set.of(AccountType.PERSONAL, AccountType.CORPORATE);
        List<SystemAccounts> results = repository.findAllByUserCodes(accountTypes);

        // Verify results are returned and types match
        assertNotNull(results);
        assertTrue(results.size() > 0);
        results.forEach(account ->
            assertTrue(account.getUserCode().equals("PERSONAL") || account.getUserCode().equals("CORPORATE"))
        );
    }
}

Obsługa konwersji Enum na String w PostgreSQL przy użyciu Spring Boot

Podczas używania Wiosenne buty w PostgreSQL obsługa wyliczeń w zapytaniach do bazy danych często wymaga szczególnej uwagi, szczególnie gdy w grę wchodzą wyliczenia natywne zapytania SQL. Domyślnie PostgreSQL nie obsługuje bezpośrednio wyliczeń Java i zamiast tego oczekuje kompatybilnego typu danych, np Varchar Lub tekst w zapytaniach. Na przykład, gdy musimy filtrować wyniki na podstawie wyliczenia typu AccountType, PostgreSQL wymaga od nas przekonwertowania wyliczenia Java na wartość ciągu przed wykonaniem zapytania. Ta konwersja zapobiega typowemu błędowi „operator nie istnieje”, który występuje, gdy baza danych próbuje porównać wyliczenie z niezgodnym typem, takim jak smallint lub zmiana znaku.

Jednym ze sposobów rozwiązania tego problemu jest wykorzystanie @Enumerated(EnumType.STRING) adnotacja w Spring Boot, która przechowuje wyliczenia jako wartości łańcuchowe bezpośrednio w bazie danych. Jednak w przypadku scenariuszy obejmujących zapytania natywne często konieczne jest przekonwertowanie wyliczeń na ciągi znaków w samym zapytaniu. Używając metod takich jak .stream() I map(Enum::name), możemy wygenerować listę ciągów reprezentujących nasze wartości wyliczeniowe, które można następnie przekazać do PostgreSQL bez żadnych problemów z niezgodnością typów. Takie podejście zapewnia elastyczność, umożliwiając płynne i bezbłędne filtrowanie według wielu wartości AccountType.

W przypadku aplikacji o bardziej złożonym zastosowaniu wyliczeń innym podejściem jest użycie metody CriteriaBuilder API, które pozwala nam dynamicznie konstruować zapytania w sposób bezpieczny dla typów, bez konieczności ręcznego pisania SQL. Ten interfejs API jest szczególnie przydatny do tworzenia kodu wielokrotnego użytku i niezależnego od bazy danych, ponieważ automatycznie tłumaczy wyliczenia na kompatybilne typy baz danych, zmniejszając ryzyko błędów typów. Dzięki tej metodzie proces konstruowania zapytań jest uproszczony, a programiści zyskują elastyczność w zakresie obsługi różnych filtrów opartych na wyliczeniach w ujednolicony sposób.