Oprava chyby Spring Boot: Proměnlivé postavy a typy Smallint nemají operátora

Běžná úskalí s Spring Boot SQL Query: Řešení neshod typů v PostgreSQL

Jako vývojáři jsme se všichni setkali s tajemnými chybovými zprávami, které jako by přicházely odnikud. Minutu, naše Aplikace Spring Boot běží hladce; dále se díváme na chybu o nekompatibilních typech dat. 😅 Je to frustrující a matoucí, zvláště když se zabýváte složitým nastavením dotazů.

Nedávno jsem narazil na chybu PostgreSQL v Spring Boot: "operátor neexistuje: charakter měnící se = smallint." Tato zpráva se objevila při pokusu o použití a Sada výčtů v klauzuli IN dotazu SQL. Neshoda mezi typem výčtu a typem sloupce databáze způsobila neočekávané zadrhnutí v tom, co vypadalo jako přímočarý kód.

I když je lákavé obviňovat databázové vtipy nebo Spring Boot, skutečný problém často spočívá v tom, jak jsou mapována výčty a typy databází. Výčty Java, když jsou mapovány do databází, vyžadují zvláštní zacházení, zejména s PostgreSQL. Pochopení těchto podrobností může ušetřit čas a předejít budoucím problémům při práci s výčty ve Spring Boot.

V této příručce vysvětlím, jak jsem identifikoval problém a prošel praktickým řešením. Od mé vlastní cesty ladění ke konkrétním opravám kódu získáte nástroje, které potřebujete, abyste se vyhnuli neshodám typů ve vašich dotazech a zajistili bezproblémové interakce s databází. 🔧

Řešení neshod datových typů v Spring Boot s PostgreSQL

Při práci s Jarní bota a PostgreSQL se vývojáři často setkávají s problémy s nesouladem typů, zejména u výčtů. V tomto případě dojde k chybě „operátor neexistuje: charakter se mění = smallint“, protože PostgreSQL nemůže přímo interpretovat Java enum jako typ SQL v nativních dotazech. Entita SystemAccounts zde zahrnuje pole userCode reprezentované výčtem AccountType, které mapuje hodnoty jako „PERSONAL“ nebo „CORPORATE“ v jazyce Java. Při pokusu o nativní SQL dotaz se sadou výčtů však PostgreSQL nedokáže automaticky přiřadit typy výčtů, což vede k této chybě. Abyste tomu zabránili, je důležité převést výčet na řetězec, než jej předáte dotazu. 🎯

V poskytnutém řešení začneme úpravou mapování výčtu v SystemAccounts pomocí anotace @Enumerated(EnumType.STRING). To dává JPA pokyn, aby uložil každý typ účtu jako čitelný řetězec namísto číselné řadové číslice. Je to malá změna, ale zjednodušuje budoucí manipulaci s daty tím, že se vyhýbá číselným hodnotám, což by zkomplikovalo ladění v databázi. V našem úložišti pak můžeme použít vlastní anotaci @Query k určení logiky SQL. Protože však PostgreSQL stále potřebuje výčty jako řetězce v dotazu, musíme před jejich předáním zpracovat hodnoty AccountType do formátu řetězce.

CriteriaBuilder API nabízí dynamické řešení tohoto problému. Pomocí CriteriaBuilder se můžeme vyhnout nativnímu SQL vytvářením dotazů programově v Javě. Tento přístup nám umožňuje přidávat filtry výčtu bez ručního psaní SQL, což snižuje chyby SQL a pomáhá s údržbou. V našem skriptu vytváříme seznam predikátových podmínek na základě hodnoty řetězce každého výčtu pomocí cb.equal() ke shodě s každým AccountType v sadě. Potom cb.or() zkombinuje tyto predikáty a umožní více hodnot ve stejném dotazu. Toto flexibilní nastavení dynamicky spravuje převod enum-na-string a minimalizuje problémy s kompatibilitou s PostgreSQL.

Nakonec řešení zahrnuje test jednotky pro ověření kompatibility. Pomocí JUnit potvrzujeme, že každý typ účtu funguje s naším dotazem a ověřujeme, že pole userCode může ukládat hodnoty „PERSONAL“ nebo „CORPORATE“ a načítat je bez chyb. Tato testovací metoda nejprve nastaví požadované hodnoty AccountType a spustí dotaz findAllByUserCodes() ke kontrole výsledků. Přidání kontrolních metodassesNotNull() assesTrue() zaručuje, že nenarazíme na hodnoty null nebo nesprávné, což zajišťuje, že naše řešení efektivně zpracuje všechny případy. S tímto nastavením je aplikace lépe připravena na zpracování výčtových dotazů napříč různými podmínkami v produkci. 🧪

// 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"))
        );
    }
}

Obsluha konverze Enum na řetězec v PostgreSQL pomocí Spring Boot

Při použití Jarní bota s PostgreSQL vyžaduje manipulace s výčty v databázových dotazech často zvláštní pozornost, zejména pokud se jedná o výčty nativní SQL dotazy. Ve výchozím nastavení PostgreSQL nepodporuje výčty Java přímo a místo toho očekává kompatibilní datový typ jako varchar nebo text v dotazech. Když například potřebujeme filtrovat výsledky na základě výčtu, jako je AccountType, PostgreSQL vyžaduje, abychom před provedením dotazu převedli výčet Java na hodnotu řetězce. Tato konverze zabraňuje běžné chybě „operátor neexistuje“, ke které dochází, když se databáze pokouší porovnat výčet s nekompatibilním typem, jako je smallint nebo proměnlivé znaky.

Jedním ze způsobů, jak tento problém vyřešit, je využít @Enumerated(EnumType.STRING) anotace v aplikaci Spring Boot, která ukládá výčty jako řetězcové hodnoty přímo v databázi. U scénářů zahrnujících nativní dotazy je však často nutné převést výčty na řetězce v rámci samotného dotazu. Pomocí metod jako .stream() a map(Enum::name), můžeme vygenerovat seznam reprezentací řetězců pro naše výčtové hodnoty, které pak lze předat PostgreSQL bez problémů s nesouladem typů. Tento přístup zajišťuje flexibilitu a umožňuje nám bezproblémově a bez chyb filtrovat podle více hodnot AccountType.

Pro aplikace se složitějším použitím výčtu je dalším přístupem použití CriteriaBuilder API, které nám umožňuje dynamicky vytvářet dotazy typově bezpečným způsobem bez ručního psaní SQL. Toto rozhraní API je zvláště užitečné pro vytváření opakovaně použitelného kódu agnostického pro databáze, protože automaticky převádí výčty do kompatibilních databázových typů, čímž snižuje riziko typových chyb. Díky této metodě je proces vytváření dotazů zjednodušen a vývojáři získají flexibilitu pro práci s různými filtry založenými na výčtu jednotným způsobem.