Pavasara sāknēšanas kļūdas labošana: rakstzīmes mainās, un Smallint veidiem nav operatora

Bieži sastopamās kļūmes ar Spring Boot SQL vaicājumiem: veidu neatbilstību apstrāde programmā PostgreSQL

Kā izstrādātāji mēs visi esam saskārušies ar noslēpumainiem kļūdu ziņojumiem, kas, šķiet, nāk no nekurienes. Vienu minūti, mūsu Lietojumprogramma Spring Boot darbojas nevainojami; Nākamajā gadījumā mēs redzam kļūdu par nesaderīgiem datu veidiem. 😅 Tas ir gan apgrūtinoši, gan mulsinoši, it īpaši, ja tiek veikti sarežģīti vaicājumu iestatījumi.

Nesen es saskāros ar PostgreSQL kļūdu Spring Boot: "operators neeksistē: rakstzīme mainās = smallint." Šis ziņojums tika parādīts, mēģinot izmantot a Enumu komplekts SQL vaicājuma IN klauzulā. Neatbilstība starp enum veidu un datu bāzes kolonnas tipu radīja negaidītu žagas kodu, kas šķita vienkāršs.

Lai gan ir vilinoši vainot datubāzes dīvainības vai Spring Boot, patiesā problēma bieži vien ir tajā, kā tiek kartēti enums un datu bāzes veidi. Ja Java enums tiek kartēts uz datu bāzēm, ir nepieciešama īpaša apstrāde, īpaši ar PostgreSQL. Izpratne par šīm detaļām var ietaupīt laiku un novērst turpmākas problēmas, strādājot ar enums programmā Spring Boot.

Šajā rokasgrāmatā es paskaidrošu, kā es identificēju problēmu un praktisku risinājumu. No mana atkļūdošanas ceļa līdz konkrētiem koda labojumiem jūs iegūsit nepieciešamos rīkus, lai izvairītos no veidu neatbilstības vaicājumos un nodrošinātu netraucētu datubāzes mijiedarbību. 🔧

Datu tipu neatbilstību novēršana pavasara sāknēšanas laikā, izmantojot PostgreSQL

Strādājot ar Pavasara zābaki un PostgreSQL, izstrādātāji bieži saskaras ar tipu neatbilstības problēmām, īpaši ar enums. Šajā gadījumā kļūda "operators neeksistē: rakstzīme mainās = smallint", jo PostgreSQL nevar tieši interpretēt Java enum kā SQL veidu vietējos vaicājumos. Šeit SystemAccounts entītija ietver lauku userCode, ko attēlo AccountType enum, kas kartē Java tādas vērtības kā "PERSONAL" vai "CORPORATE". Tomēr, mēģinot veikt vietējo SQL vaicājumu ar enumu kopu, PostgreSQL nevar automātiski saskaņot enum tipus, kā rezultātā rodas šī kļūda. Lai to novērstu, ir ļoti svarīgi pārveidot enum par virkni pirms tās nodošanas vaicājumam. 🎯

Piedāvātajā risinājumā mēs sākam ar enum kartēšanas pielāgošanu SystemAccounts, izmantojot @Enumerated(EnumType.STRING) anotāciju. Tas uzdod JPA saglabāt katru konta veidu kā lasāmu virkni, nevis ciparu kārtas skaitli. Tās ir nelielas izmaiņas, taču tās vienkāršo turpmāko datu apstrādi, izvairoties no skaitliskām vērtībām, kas datu bāzē padarītu atkļūdošanu sarežģītu. Pēc tam savā repozitorijā mēs varam izmantot pielāgotu @Query anotāciju, lai norādītu SQL loģiku. Tomēr, tā kā PostgreSQL vaicājumā joprojām ir nepieciešami enums kā virknes, mums ir jāapstrādā AccountType vērtības virknes formātā pirms to nodošanas.

CriteriaBuilder API piedāvā dinamisku šīs problēmas risinājumu. Izmantojot CriteriaBuilder, mēs varam izvairīties no vietējās SQL, programmatiski veidojot vaicājumus Java. Šī pieeja ļauj mums pievienot enum filtrus, nerakstot SQL ar roku, kas samazina SQL kļūdas un palīdz uzturēt apkopi. Mūsu skriptā mēs izveidojam predikātu nosacījumu sarakstu, pamatojoties uz katras enum virknes vērtību, izmantojot cb.equal(), lai atbilstu katram konta veidam komplektā. Pēc tam cb.or() apvieno šos predikātus, ļaujot vienā vaicājumā izmantot vairākas vērtības. Šī elastīgā iestatīšana dinamiski pārvalda pārveidošanu no enum uz virkni, samazinot saderības problēmas ar PostgreSQL.

Visbeidzot, risinājumā ir iekļauts vienības tests, lai pārbaudītu saderību. Izmantojot JUnit, mēs apstiprinām, ka katrs konta tips darbojas ar mūsu vaicājumu, apstiprinot, ka lauks userCode var saglabāt "PERSONAL" vai "CORPORATE" vērtības un izgūt tās bez kļūdām. Šī testa metode vispirms iestata vajadzīgās AccountType vērtības un palaiž vaicājumu findAllByUserCodes(), lai pārbaudītu rezultātus. AssertNotNull() un assertTrue() pārbaužu pievienošana garantē, ka netiks konstatētas nulles vai nepareizas vērtības, nodrošinot, ka mūsu risinājums efektīvi apstrādā visus gadījumus. Izmantojot šo iestatījumu, lietojumprogramma ir labāk sagatavota, lai apstrādātu enum vaicājumus dažādos ražošanas apstākļos. 🧪

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

Apstrādājiet Enum konvertēšanu uz virkni programmā PostgreSQL, izmantojot Spring Boot

Lietojot Pavasara zābaki Izmantojot PostgreSQL, enumu apstrādei datu bāzes vaicājumos bieži ir jāpievērš īpaša uzmanība, it īpaši, ja enums ir iesaistīts vietējie SQL vaicājumi. Pēc noklusējuma PostgreSQL tieši neatbalsta Java enums, un tā vietā sagaida saderīgu datu tipu, piemēram, varchar vai tekstu vaicājumos. Piemēram, ja mums ir jāfiltrē rezultāti, pamatojoties uz tādu uzskaitījumu kā AccountType, PostgreSQL pieprasa, lai pirms vaicājuma izpildīšanas Java enum būtu jāpārvērš par virknes vērtību. Šī pārveidošana novērš izplatīto kļūdu “operators neeksistē”, kas rodas, kad datu bāze mēģina salīdzināt enum ar nesaderīgu veidu, piemēram, smallint vai rakstzīmju mainīgumu.

Viens no veidiem, kā risināt šo problēmu, ir izmantot @Enumerated(EnumType.STRING) anotācija programmā Spring Boot, kas saglabā enumus kā virknes vērtības tieši datu bāzē. Tomēr scenārijos, kas saistīti ar vietējiem vaicājumiem, enums bieži ir jāpārvērš virknēs pašā vaicājumā. Izmantojot tādas metodes kā .stream() un map(Enum::name), mēs varam ģenerēt virkņu attēlojumu sarakstu mūsu enum vērtībām, ko pēc tam var nodot PostgreSQL bez veida neatbilstības problēmām. Šī pieeja nodrošina elastību, ļaujot mums nemanāmi bez kļūdām filtrēt pēc vairākām AccountType vērtībām.

Lietojumprogrammām ar sarežģītāku enum lietojumu cita pieeja ir izmantot CriteriaBuilder API, kas ļauj mums dinamiski veidot vaicājumus tipa drošā veidā, manuāli neierakstot SQL. Šī API ir īpaši noderīga, lai izveidotu atkārtoti lietojamu un datubāzes agnostisku kodu, jo tā automātiski pārvērš enums saderīgos datu bāzes tipos, samazinot tipa kļūdu risku. Izmantojot šo metodi, vaicājumu veidošanas process tiek vienkāršots, un izstrādātāji iegūst elastību, lai vienoti apstrādātu dažādus uz enum balstītus filtrus.