Åtgärda Spring Boot-felet: Teckenvarierande och Smallint-typer har ingen operatör

Vanliga fallgropar med Spring Boot SQL-frågor: Hantering av typfel i PostgreSQL

Som utvecklare har vi alla stött på kryptiska felmeddelanden som verkar komma från ingenstans. En minut, vår Spring Boot-applikation går smidigt; nästa, vi stirrar på ett felmeddelande om inkompatibla datatyper. 😅 Det är både frustrerande och förbryllande, särskilt när man hanterar komplexa frågeinställningar.

Nyligen stötte jag på ett PostgreSQL-fel i Spring Boot: "operator finns inte: tecken varierande = smallint." Det här meddelandet dök upp när du försökte använda en Uppsättning uppräkningar i en SQL-frågas IN-klausul. Missmatchningen mellan enum-typen och databaskolumntypen skapade en oväntad hicka i vad som verkade vara okomplicerad kod.

Även om det är frestande att skylla på databasquirks eller Spring Boot, ligger den verkliga frågan ofta i hur enums och databastyper kartläggs. Java enums, när de mappas till databaser, kräver speciell hantering, särskilt med PostgreSQL. Att förstå dessa detaljer kan spara tid och förhindra framtida problem när du arbetar med enums i Spring Boot.

I den här guiden kommer jag att förklara hur jag identifierade problemet och gick igenom en praktisk lösning. Från min egen felsökningsresa till specifika kodfixar, får du de verktyg du behöver för att undvika typfel i dina frågor och säkerställa sömlös databasinteraktion. 🔧

Lösning av datatypfel i Spring Boot med PostgreSQL

När man arbetar med Fjäderkänga och PostgreSQL stöter utvecklare ofta på problem med typfel, särskilt med enums. I det här fallet inträffar felet "operator existerar inte: tecken varierande = smallint" eftersom PostgreSQL inte direkt kan tolka en Java-enum som en SQL-typ i inbyggda frågor. Här inkluderar SystemAccounts-entiteten ett userCode-fält representerat av AccountType enum, som mappar värden som "PERSONAL" eller "CORPORATE" i Java. Men när du försöker en inbyggd SQL-fråga med en uppsättning enums, kan PostgreSQL inte automatiskt matcha enum-typer, vilket resulterar i detta fel. För att övervinna detta är det viktigt att konvertera enummet till en sträng innan du skickar det till frågan. 🎯

I den tillhandahållna lösningen börjar vi med att justera enum-mappningen i SystemAccounts med @Enumerated(EnumType.STRING)-anteckningen. Detta instruerar JPA att lagra varje AccountType som en läsbar sträng istället för en numerisk ordningsföljd. Det är en liten förändring, men det förenklar framtida datahantering genom att undvika numeriska värden, vilket skulle göra felsökningen komplex i databasen. I vårt arkiv kan vi sedan använda en anpassad @Query-anteckning för att specificera SQL-logiken. Men eftersom PostgreSQL fortfarande behöver enums som strängar i frågan, måste vi bearbeta AccountType-värdena till ett strängformat innan vi skickar in dem.

CriteriaBuilder API erbjuder en dynamisk lösning på detta problem. Med CriteriaBuilder kan vi undvika inbyggd SQL genom att skapa frågor programmatiskt i Java. Detta tillvägagångssätt gör det möjligt för oss att lägga till enumfilter utan att skriva SQL för hand, vilket minskar SQL-fel och hjälper till med underhåll. I vårt skript skapar vi en lista med predikatvillkor baserat på varje enums strängvärde, med hjälp av cb.equal() för att matcha varje AccountType i setet. Sedan kombinerar cb.or() dessa predikat, vilket tillåter flera värden i samma fråga. Denna flexibla installation hanterar dynamiskt enum-till-sträng-konverteringen, vilket minimerar kompatibilitetsproblem med PostgreSQL.

Slutligen innehåller lösningen ett enhetstest för att verifiera kompatibiliteten. Genom att använda JUnit bekräftar vi att varje AccountType fungerar med vår fråga, och validerar att userCode-fältet kan lagra "PERSONAL" eller "CORPORATE" värden och hämta dem utan fel. Den här testmetoden ställer först in de nödvändiga AccountType-värdena och kör sökfrågan findAllByUserCodes() för att kontrollera resultaten. Att lägga till assertNotNull() och assertTrue() kontroller garanterar att vi inte stöter på null eller felaktiga värden, vilket säkerställer att vår lösning hanterar alla fall effektivt. Med denna inställning är applikationen bättre förberedd för att hantera enum-frågor över olika förhållanden i produktionen. 🧪

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

Hantera Enum till String Conversion i PostgreSQL med Spring Boot

Vid användning Fjäderkänga med PostgreSQL kräver hantering av enums i databasfrågor ofta särskild uppmärksamhet, särskilt när enums är involverade i inbyggda SQL-frågor. Som standard stöder PostgreSQL inte Java-enums direkt, utan förväntar sig istället en kompatibel datatyp som varchar eller text i frågor. Till exempel, när vi behöver filtrera resultat baserat på en enum som AccountType, kräver PostgreSQL att vi konverterar Java enum till ett strängvärde innan vi kör frågan. Denna omvandling förhindrar det vanliga felet "operatör existerar inte", som uppstår när databasen försöker jämföra en enum med en inkompatibel typ som smallint eller teckenvarierande.

Ett sätt att hantera denna fråga är att utnyttja @Enumerated(EnumType.STRING) annotation i Spring Boot, som lagrar enums som strängvärden direkt i databasen. Men för scenarier som involverar inbyggda frågor är det ofta nödvändigt att konvertera uppräkningarna till strängar i själva frågan. Genom att använda metoder som .stream() och map(Enum::name), kan vi generera en lista med strängrepresentationer för våra enum-värden, som sedan kan skickas till PostgreSQL utan problem med typfel. Detta tillvägagångssätt säkerställer flexibilitet, vilket gör att vi kan filtrera efter flera AccountType-värden sömlöst utan fel.

För applikationer med mer komplex enumanvändning är ett annat tillvägagångssätt att använda CriteriaBuilder API, som låter oss dynamiskt konstruera frågor på ett typsäkert sätt utan att manuellt skriva SQL. Detta API är särskilt användbart för att skapa återanvändbar och databasagnostisk kod, eftersom den automatiskt översätter uppräkningar till kompatibla databastyper, vilket minskar risken för typfel. Med denna metod förenklas frågekonstruktionsprocessen och utvecklare får flexibiliteten att hantera olika enumbaserade filter på ett enhetligt sätt.