Ispravljanje pogreške Spring Boot Error: Character Varying i Smallint tipovi nemaju operator

Uobičajene zamke s Spring Boot SQL upitima: rukovanje nepodudaranjem tipa u PostgreSQL-u

Kao programeri, svi smo se susreli sa zagonetnim porukama o pogreškama koje kao da dolaze niotkuda. Minutu, naš Aplikacija Spring Boot radi glatko; sljedeće, buljimo u pogrešku o nekompatibilnim tipovima podataka. 😅 To je i frustrirajuće i zbunjujuće, posebno kada se radi o složenim postavkama upita.

Nedavno sam naišao na pogrešku PostgreSQL u Spring Boot-u: "operator ne postoji: variranje znakova = smallint." Ova poruka se pojavila prilikom pokušaja korištenja a Skup enuma u klauzuli IN SQL upita. Neusklađenost između tipa enum i tipa stupca baze podataka stvorila je neočekivani problem u onome što se činilo kao jednostavan kod.

Iako je primamljivo okriviti nepravilnosti u bazi podataka ili Spring Boot, pravi problem često leži u načinu mapiranja popisa i tipova baza podataka. Java enumi, kada se mapiraju u baze podataka, zahtijevaju posebno rukovanje, posebno s PostgreSQL. Razumijevanje ovih pojedinosti može uštedjeti vrijeme i spriječiti buduće probleme pri radu s enumima u Spring Bootu.

U ovom ću vodiču objasniti kako sam identificirao problem i prošao kroz praktično rješenje. Od mog vlastitog putovanja otklanjanja pogrešaka do specifičnih popravaka koda, dobit ćete alate koji su vam potrebni da biste izbjegli nepodudaranje tipa u svojim upitima i osigurali besprijekornu interakciju baze podataka. 🔧

Rješavanje nepodudarnosti tipova podataka u Spring pokretanju s PostgreSQL

Prilikom rada sa Proljetna čizma i PostgreSQL, programeri se često susreću s problemima neusklađenosti tipa, posebno s enumima. U ovom slučaju, pogreška "operator does not exist: character varying = smallint" događa se jer PostgreSQL ne može izravno interpretirati Java enum kao SQL tip u nativnim upitima. Ovdje entitet SystemAccounts uključuje polje userCode predstavljeno enumom AccountType, koji preslikava vrijednosti poput "PERSONAL" ili "CORPORATE" u Javi. Međutim, prilikom pokušaja izvornog SQL upita sa skupom enuma, PostgreSQL ne može automatski uskladiti tipove enuma, što rezultira ovom pogreškom. Da biste to prevladali, ključno je pretvoriti enum u niz prije nego što ga proslijedite upitu. 🎯

U ponuđenom rješenju počinjemo prilagodbom preslikavanja enuma u SystemAccounts pomoću oznake @Enumerated(EnumType.STRING). Ovo upućuje JPA da pohrani svaki AccountType kao čitljiv niz umjesto numeričkog ordinala. To je mala promjena, ali pojednostavljuje buduće rukovanje podacima izbjegavanjem numeričkih vrijednosti, koje bi otklanjanje pogrešaka u bazi podataka učinile složenim. U našem repozitoriju tada možemo upotrijebiti prilagođenu @Query napomenu za određivanje SQL logike. Međutim, budući da PostgreSQL i dalje treba enume kao nizove u upitu, moramo obraditi AccountType vrijednosti u format niza prije nego ih proslijedimo.

CriteriaBuilder API nudi dinamičko rješenje za ovaj problem. Koristeći CriteriaBuilder, možemo izbjeći izvorni SQL izradom upita programski u Javi. Ovaj nam pristup omogućuje dodavanje enum filtara bez ručnog pisanja SQL-a, što smanjuje SQL pogreške i pomaže u održavanju. U našoj skripti stvaramo popis predikatnih uvjeta na temelju vrijednosti niza svakog enuma, koristeći cb.equal() za podudaranje svake vrste računa u skupu. Zatim, cb.or() kombinira ove predikate, dopuštajući više vrijednosti u istom upitu. Ova fleksibilna postavka dinamički upravlja pretvorbom enum-to-string, minimizirajući probleme kompatibilnosti s PostgreSQL-om.

Konačno, rješenje uključuje jedinični test za provjeru kompatibilnosti. Koristeći JUnit, potvrđujemo da svaki AccountType radi s našim upitom, potvrđujući da polje userCode može pohraniti vrijednosti "PERSONAL" ili "CORPORATE" i dohvatiti ih bez pogrešaka. Ova testna metoda prvo postavlja potrebne vrijednosti AccountType i pokreće upit findAllByUserCodes() za provjeru rezultata. Dodavanje provjera assertNotNull() i assertTrue() jamči da nećemo naići na null ili netočne vrijednosti, osiguravajući da naše rješenje učinkovito obrađuje sve slučajeve. Uz ovu postavku, aplikacija je bolje pripremljena za rukovanje enum upitima u različitim uvjetima u proizvodnji. 🧪

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

Rukovanje pretvorbom enuma u string u PostgreSQL-u uz Spring pokretanje

Prilikom korištenja Proljetna čizma uz PostgreSQL, rukovanje enumima u upitima baze podataka često zahtijeva posebnu pozornost, osobito kada su enumi uključeni u izvorni SQL upiti. Prema zadanim postavkama, PostgreSQL ne podržava izravno Java enume, i umjesto toga očekuje kompatibilan tip podataka kao što je varchar ili tekst u upitima. Na primjer, kada trebamo filtrirati rezultate na temelju enuma kao što je AccountType, PostgreSQL zahtijeva od nas da pretvorimo Java enum u vrijednost niza prije izvršavanja upita. Ova pretvorba sprječava uobičajenu pogrešku "operator ne postoji", koja se pojavljuje kada baza podataka pokuša usporediti enum s nekompatibilnim tipom kao što je smallint ili promjenjivi znak.

Jedan od načina rješavanja ovog problema je iskoristiti @Enumerated(EnumType.STRING) anotacija u Spring Bootu, koja pohranjuje enume kao vrijednosti niza izravno u bazu podataka. Međutim, za scenarije koji uključuju izvorne upite, često je potrebno pretvoriti enume u nizove unutar samog upita. Korištenjem metoda kao što su .stream() i map(Enum::name), možemo generirati popis reprezentacija nizova za naše enum vrijednosti, koje se zatim mogu proslijediti PostgreSQL-u bez ikakvih problema s nepodudaranjem tipa. Ovaj pristup osigurava fleksibilnost, omogućujući nam neprimjetno filtriranje prema višestrukim vrijednostima AccountType bez pogrešaka.

Za aplikacije sa složenijom upotrebom enuma, drugi pristup je korištenje CriteriaBuilder API, koji nam omogućuje dinamičku konstrukciju upita na siguran način bez ručnog pisanja SQL-a. Ovaj API je posebno koristan za stvaranje koda koji se može višekratno koristiti i koda koji ne ovisi o bazi podataka, budući da automatski prevodi enume u kompatibilne tipove baza podataka, smanjujući rizik od tipskih pogrešaka. S ovom metodom, proces konstrukcije upita je pojednostavljen, a programeri dobivaju fleksibilnost za rukovanje različitim filtrima koji se temelje na enum-u na jedinstven način.