Odpravljanje napake spomladanskega zagona: Vrste znakov, ki se spreminjajo in Smallint, nimajo operaterja

Pogoste pasti pri poizvedbah SQL spomladanskega zagona: obravnava neujemanja vrst v PostgreSQL

Kot razvijalci smo vsi naleteli na skrivnostna sporočila o napakah, za katera se zdi, da se pojavijo od nikoder. Eno minuto, naš Aplikacija Spring Boot deluje gladko; naslednjič, strmimo v napako o nezdružljivih tipih podatkov. 😅 To je hkrati frustrirajuće in zaskrbljujoče, zlasti ko imamo opravka s kompleksnimi nastavitvami poizvedb.

Pred kratkim sem pri pomladnem zagonu naletel na napako PostgreSQL: "operator ne obstaja: spreminjanje znakov = smallint." To sporočilo se je pojavilo med poskusom uporabe a Niz enumov v klavzuli IN poizvedbe SQL. Neusklajenost med tipom enum in tipom stolpca zbirke podatkov je povzročila nepričakovano kolcanje v tem, kar se je zdelo kot enostavna koda.

Čeprav je skušnjava kriviti nenavadnosti baze podatkov ali Spring Boot, je prava težava pogosto v tem, kako so enume in vrste baze podatkov preslikani. Javanski enumi, ko so preslikani v baze podatkov, zahtevajo posebno obravnavo, zlasti s PostgreSQL. Razumevanje teh podrobnosti lahko prihrani čas in prepreči prihodnje težave pri delu z enumi v programu Spring Boot.

V tem priročniku bom razložil, kako sem prepoznal težavo in predstavil praktično rešitev. Od moje lastne poti odpravljanja napak do določenih popravkov kode boste pridobili orodja, ki jih potrebujete, da se izognete neujemanju tipov v svojih poizvedbah in zagotovite nemoteno interakcijo z bazo podatkov. 🔧

Odpravljanje neujemanja tipov podatkov pri spomladanskem zagonu s PostgreSQL

Pri delu z Pomladni škorenj in PostgreSQL razvijalci pogosto naletijo na težave z neujemanjem tipov, zlasti pri enumih. V tem primeru pride do napake »operator ne obstaja: spreminjanje znakov = smallint«, ker PostgreSQL ne more neposredno interpretirati enuma Java kot vrste SQL v izvornih poizvedbah. Tu entiteta SystemAccounts vključuje polje userCode, ki ga predstavlja enum AccountType, ki preslika vrednosti, kot sta »PERSONAL« ali »CORPORATE« v Javi. Vendar pa pri poskusu izvorne poizvedbe SQL z naborom enumov PostgreSQL ne more samodejno ujemati tipov enumov, kar povzroči to napako. Da bi to odpravili, je ključnega pomena, da enum pretvorite v niz, preden ga posredujete poizvedbi. 🎯

V ponujeni rešitvi začnemo s prilagoditvijo preslikave enum v SystemAccounts z uporabo pripisa @Enumerated(EnumType.STRING). To naroči JPA, naj shrani vsak AccountType kot berljiv niz namesto številskega ordinala. To je majhna sprememba, vendar poenostavlja prihodnje ravnanje s podatki z izogibanjem številčnim vrednostim, zaradi katerih bi bilo odpravljanje napak v bazi podatkov zapleteno. V našem repozitoriju lahko nato uporabimo pripis @Query po meri, da določimo logiko SQL. Ker pa PostgreSQL še vedno potrebuje enume kot nize v poizvedbi, moramo vrednosti AccountType obdelati v obliko niza, preden jih posredujemo.

API CriteriaBuilder ponuja dinamično rešitev za to težavo. Z uporabo CriteriaBuilder se lahko izognemo izvornemu SQL tako, da programsko gradimo poizvedbe v Javi. Ta pristop nam omogoča dodajanje filtrov enum brez ročnega pisanja SQL, kar zmanjša napake SQL in pomaga pri vzdrževanju. V našem skriptu ustvarimo seznam predikatnih pogojev na podlagi vrednosti niza vsakega enum z uporabo cb.equal() za ujemanje z vsako vrsto računa v naboru. Nato cb.or() združi te predikate in omogoči več vrednosti v isti poizvedbi. Ta prilagodljiva nastavitev dinamično upravlja pretvorbo enum v niz, kar zmanjša težave z združljivostjo s PostgreSQL.

Končno rešitev vključuje test enote za preverjanje združljivosti. Z uporabo JUnit potrdimo, da vsak AccountType deluje z našo poizvedbo, pri čemer potrdimo, da lahko polje userCode shrani vrednosti »PERSONAL« ali »CORPORATE« in jih pridobi brez napak. Ta preizkusna metoda najprej nastavi zahtevane vrednosti AccountType in zažene poizvedbo findAllByUserCodes(), da preveri rezultate. Dodajanje preverjanj assertNotNull() in assertTrue() zagotavlja, da ne naletimo na ničelne ali nepravilne vrednosti, kar zagotavlja, da naša rešitev učinkovito obravnava vse primere. S to nastavitvijo je aplikacija bolje pripravljena za obravnavanje poizvedb enum v različnih pogojih v 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"))
        );
    }
}

Ravnanje s pretvorbo enum v niz v PostgreSQL s pomladnim zagonom

Pri uporabi Pomladni škorenj s PostgreSQL obravnavanje enumov v poizvedbah baze podatkov pogosto zahteva posebno pozornost, zlasti kadar so enumi vključeni v izvorne poizvedbe SQL. PostgreSQL privzeto ne podpira neposredno enumov Java in namesto tega pričakuje združljiv podatkovni tip, kot je varchar oz besedilo v poizvedbah. Na primer, ko moramo filtrirati rezultate na podlagi enuma, kot je AccountType, PostgreSQL od nas zahteva, da enum Java pretvorimo v vrednost niza, preden izvedemo poizvedbo. Ta pretvorba prepreči običajno napako »operator ne obstaja«, do katere pride, ko zbirka podatkov poskuša primerjati enum z nezdružljivim tipom, kot je smallint ali spreminjanje znakov.

Eden od načinov za reševanje te težave je izkoriščanje @Enumerated(EnumType.STRING) opomba v Spring Boot, ki shranjuje enume kot nizovne vrednosti neposredno v bazo podatkov. Vendar pa je za scenarije, ki vključujejo izvorne poizvedbe, pogosto treba pretvoriti enume v nize znotraj same poizvedbe. Z uporabo metod, kot je .stream() in map(Enum::name), lahko ustvarimo seznam predstavitev nizov za naše enum vrednosti, ki jih lahko nato posredujemo v PostgreSQL brez kakršnih koli težav z neujemanjem vrst. Ta pristop zagotavlja prilagodljivost, ki nam omogoča nemoteno filtriranje po več vrednostih AccountType brez napak.

Za aplikacije z bolj zapleteno uporabo enum je drug pristop uporaba CriteriaBuilder API, ki nam omogoča dinamično sestavljanje poizvedb na tipsko varen način brez ročnega pisanja SQL. Ta API je še posebej uporaben za ustvarjanje kode za večkratno uporabo in kode, neodvisne od baze podatkov, saj samodejno prevede enume v združljive tipe baze podatkov, s čimer zmanjša tveganje za napake tipa. S to metodo je postopek gradnje poizvedbe poenostavljen, razvijalci pa pridobijo prilagodljivost za poenoteno upravljanje različnih filtrov, ki temeljijo na enumih.