ஸ்பிரிங் பூட் பிழையை சரிசெய்தல்: எழுத்து மாறுபடும் மற்றும் சிறிய வகைகளுக்கு ஆபரேட்டர் இல்லை

ஸ்பிரிங் பூட் SQL வினவல்களுடன் பொதுவான பிட்ஃபால்ஸ்: PostgreSQL இல் வகை பொருந்தாதவற்றைக் கையாளுதல்

டெவலப்பர்களாகிய நாம் அனைவரும் மறைமுகமான பிழைச் செய்திகளை எதிர்கொண்டுள்ளோம், அவை எங்கும் வெளிவரவில்லை. ஒரு நிமிடம், எங்கள் ஸ்பிரிங் பூட் பயன்பாடு சீராக இயங்குகிறது; அடுத்தது, பொருந்தாத தரவு வகைகளைப் பற்றிய பிழையைப் பார்த்துக் கொண்டிருக்கிறோம். 😅 இது வெறுப்பாகவும் குழப்பமாகவும் இருக்கிறது, குறிப்பாக சிக்கலான வினவல் அமைப்புகளைக் கையாளும் போது.

சமீபத்தில், ஸ்பிரிங் பூட்டில் PostgreSQL பிழை ஏற்பட்டது: "ஆபரேட்டர் இல்லை: எழுத்து மாறுபடும் = சிறியது." ஒரு பயன்படுத்த முயற்சிக்கும் போது இந்த செய்தி காட்டப்பட்டது எண்களின் தொகுப்பு SQL வினவலின் IN விதியில். enum வகைக்கும் தரவுத்தள நெடுவரிசை வகைக்கும் இடையே உள்ள பொருத்தமின்மை, நேரடியான குறியீடாகத் தோன்றியதில் எதிர்பாராத விக்கலை உருவாக்கியது.

தரவுத்தள வினோதங்கள் அல்லது ஸ்பிரிங் பூட் மீது குற்றம் சாட்டுவதற்கு இது தூண்டுகிறது என்றாலும், உண்மையான சிக்கல் பெரும்பாலும் enums மற்றும் தரவுத்தள வகைகள் எவ்வாறு வரைபடமாக்கப்படுகின்றன என்பதில் உள்ளது. Java enums, தரவுத்தளங்களில் மேப் செய்யப்படும்போது, ​​குறிப்பாக PostgreSQL உடன் சிறப்பு கையாளுதல் தேவைப்படுகிறது. இந்த விவரங்களைப் புரிந்துகொள்வது நேரத்தை மிச்சப்படுத்தலாம் மற்றும் ஸ்பிரிங் பூட்டில் enums உடன் பணிபுரியும் போது எதிர்கால சிக்கல்களைத் தடுக்கலாம்.

இந்த வழிகாட்டியில், நான் சிக்கலை எவ்வாறு கண்டறிந்தேன் மற்றும் ஒரு நடைமுறை தீர்வின் மூலம் நடந்தேன் என்பதை விளக்குகிறேன். எனது சொந்த பிழைத்திருத்தப் பயணத்திலிருந்து குறிப்பிட்ட குறியீடு திருத்தங்கள் வரை, உங்கள் வினவல்களில் வகைப் பொருத்தமின்மைகளைத் தவிர்க்கவும், தடையற்ற தரவுத்தள தொடர்புகளை உறுதிப்படுத்தவும் தேவையான கருவிகளைப் பெறுவீர்கள். 🔧

PostgreSQL உடன் ஸ்பிரிங் பூட்டில் தரவு வகைப் பொருத்தமின்மைகளைத் தீர்ப்பது

உடன் பணிபுரியும் போது ஸ்பிரிங் பூட் மற்றும் PostgreSQL, டெவலப்பர்கள் பெரும்பாலும் வகை பொருந்தாத சிக்கல்களை எதிர்கொள்கின்றனர், குறிப்பாக enums உடன். இந்த வழக்கில், "ஆப்பரேட்டர் இல்லை: எழுத்து மாறுபடும் = சிறியது" என்ற பிழை ஏற்படுகிறது, ஏனெனில் PostgreSQL ஆனது சொந்த வினவல்களில் ஒரு ஜாவா enum ஐ SQL வகையாக நேரடியாக விளக்க முடியாது. இங்கே, SystemAccounts நிறுவனமானது AccountType enum ஆல் குறிப்பிடப்படும் பயனர் குறியீடு புலத்தை உள்ளடக்கியது, இது ஜாவாவில் "தனிப்பட்ட" அல்லது "கார்பொரேட்" போன்ற மதிப்புகளை வரைபடமாக்குகிறது. இருப்பினும், enumகளின் தொகுப்புடன் சொந்த SQL வினவலை முயற்சிக்கும்போது, ​​​​PostgreSQL தானாகவே enum வகைகளை பொருத்த முடியாது, இதன் விளைவாக இந்த பிழை ஏற்படுகிறது. இதைப் போக்க, வினவலுக்கு அனுப்புவதற்கு முன், enum ஐ சரமாக மாற்றுவது முக்கியம். 🎯

வழங்கப்பட்ட தீர்வில், @Enumerated(EnumType.STRING) சிறுகுறிப்பைப் பயன்படுத்தி SystemAccounts இல் enum மேப்பிங்கைச் சரிசெய்வதன் மூலம் தொடங்குகிறோம். ஒவ்வொரு கணக்கு வகையையும் ஒரு எண் ஆர்டினலுக்குப் பதிலாக படிக்கக்கூடிய சரமாக சேமிக்க இது JPA க்கு அறிவுறுத்துகிறது. இது ஒரு சிறிய மாற்றம், ஆனால் இது எண்ணியல் மதிப்புகளைத் தவிர்ப்பதன் மூலம் எதிர்கால தரவு கையாளுதலை எளிதாக்குகிறது, இது தரவுத்தளத்தில் பிழைத்திருத்தத்தை சிக்கலாக்கும். எங்கள் களஞ்சியத்தில், SQL லாஜிக்கைக் குறிப்பிட தனிப்பயன் @Query சிறுகுறிப்பைப் பயன்படுத்தலாம். இருப்பினும், PostgreSQL க்கு வினவலில் இன்னும் enumகள் தேவைப்படுவதால், AccountType மதிப்புகளை உள்ளிடுவதற்கு முன் அவற்றை ஒரு சர வடிவில் செயல்படுத்த வேண்டும்.

CriteriaBuilder API இந்த சிக்கலுக்கு மாறும் தீர்வை வழங்குகிறது. CriteriaBuilder ஐப் பயன்படுத்தி, ஜாவாவில் நிரல் முறையில் வினவல்களை உருவாக்குவதன் மூலம் சொந்த SQL ஐத் தவிர்க்கலாம். இந்த அணுகுமுறை SQL ஐ கையால் எழுதாமல் enum வடிப்பான்களைச் சேர்க்க உதவுகிறது, இது SQL பிழைகளைக் குறைக்கிறது மற்றும் பராமரிக்க உதவுகிறது. எங்கள் ஸ்கிரிப்ட்டில், ஒவ்வொரு enum இன் ஸ்டிரிங் மதிப்பின் அடிப்படையில் கணிக்கப்படும் நிபந்தனைகளின் பட்டியலை உருவாக்குகிறோம், cb.equal() ஐப் பயன்படுத்தி தொகுப்பில் உள்ள ஒவ்வொரு கணக்கு வகையையும் பொருத்துவோம். பின்னர், cb.or() இந்த கணிப்புகளை ஒருங்கிணைத்து, ஒரே வினவலில் பல மதிப்புகளை அனுமதிக்கிறது. இந்த நெகிழ்வான அமைப்பு Enum-to-string மாற்றத்தை மாறும் வகையில் நிர்வகிக்கிறது, PostgreSQL உடன் பொருந்தக்கூடிய சிக்கல்களைக் குறைக்கிறது.

இறுதியாக, தீர்வு இணக்கத்தன்மையை சரிபார்க்க ஒரு அலகு சோதனையை உள்ளடக்கியது. ஜூனிட்டைப் பயன்படுத்தி, ஒவ்வொரு கணக்கு வகையும் எங்கள் வினவலுடன் செயல்படுவதை உறுதிசெய்கிறோம், பயனர் குறியீடு புலம் "தனிப்பட்ட" அல்லது "கார்ப்பரேட்" மதிப்புகளைச் சேமித்து பிழைகள் இல்லாமல் மீட்டெடுக்க முடியும் என்பதைச் சரிபார்க்கிறோம். இந்தச் சோதனை முறை முதலில் தேவையான கணக்கு வகை மதிப்புகளை அமைத்து முடிவுகளைச் சரிபார்க்க findAllByUserCodes() வினவலை இயக்குகிறது. assertNotNull() மற்றும் assertTrue() சரிபார்ப்புகளைச் சேர்ப்பது பூஜ்ய அல்லது தவறான மதிப்புகளை நாங்கள் சந்திக்க மாட்டோம் என்று உத்தரவாதம் அளிக்கிறது, எங்கள் தீர்வு எல்லா நிகழ்வுகளையும் திறம்பட கையாள்வதை உறுதிசெய்கிறது. இந்த அமைப்பின் மூலம், உற்பத்தியில் பல்வேறு நிலைகளில் enum வினவல்களைக் கையாள பயன்பாடு சிறப்பாகத் தயாராக உள்ளது. 🧪

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

ஸ்பிரிங் பூட் மூலம் PostgreSQL இல் Enum to String Conversion ஐக் கையாளுதல்

பயன்படுத்தும் போது ஸ்பிரிங் பூட் PostgreSQL உடன், தரவுத்தள வினவல்களில் enumகளைக் கையாள்வது சிறப்பு கவனம் தேவைப்படுகிறது, குறிப்பாக enumகள் இதில் ஈடுபடும்போது சொந்த SQL வினவல்கள். முன்னிருப்பாக, PostgreSQL நேரடியாக Java enums ஐ ஆதரிக்காது, மாறாக இணக்கமான தரவு வகையை எதிர்பார்க்கிறது varchar அல்லது உரை கேள்விகளில். உதாரணமாக, AccountType போன்ற enum அடிப்படையில் முடிவுகளை வடிகட்ட வேண்டியிருக்கும் போது, ​​PostgreSQL ஆனது, வினவலை இயக்கும் முன், Java enum ஐ ஒரு சர மதிப்பாக மாற்ற வேண்டும். இந்த மாற்றம் பொதுவான “ஆபரேட்டர் இல்லை” பிழையைத் தடுக்கிறது, இது தரவுத்தளமானது ஸ்மால் இன்ட் அல்லது கேரக்டர் மாறுபடும் போன்ற இணக்கமற்ற வகையுடன் ஒரு enum ஐ ஒப்பிட முயற்சிக்கும் போது ஏற்படும்.

இந்த சிக்கலைக் கையாள்வதற்கான ஒரு வழி, அதைப் பயன்படுத்துவதாகும் @Enumerated(EnumType.STRING) ஸ்பிரிங் பூட்டில் சிறுகுறிப்பு, இது enumகளை நேரடியாக தரவுத்தளத்தில் சர மதிப்புகளாக சேமிக்கிறது. இருப்பினும், நேட்டிவ் வினவல்கள் சம்பந்தப்பட்ட காட்சிகளுக்கு, வினவலுக்குள்ளேயே enumகளை சரங்களாக மாற்றுவது அவசியம். போன்ற முறைகளைப் பயன்படுத்துவதன் மூலம் .stream() மற்றும் map(Enum::name), எங்கள் enum மதிப்புகளுக்கான சரம் பிரதிநிதித்துவங்களின் பட்டியலை உருவாக்கலாம், பின்னர் எந்த வகை பொருந்தாத சிக்கல்களும் இல்லாமல் PostgreSQL க்கு அனுப்பப்படும். இந்த அணுகுமுறை நெகிழ்வுத்தன்மையை உறுதிசெய்கிறது, பிழைகள் இல்லாமல் பல கணக்கு வகை மதிப்புகளை தடையின்றி வடிகட்ட அனுமதிக்கிறது.

மிகவும் சிக்கலான enum பயன்பாட்டைக் கொண்ட பயன்பாடுகளுக்கு, மற்றொரு அணுகுமுறையைப் பயன்படுத்துவது CriteriaBuilder API, இது SQL ஐ கைமுறையாக எழுதாமல் வினவல்களை வகை-பாதுகாப்பான முறையில் மாறும் வகையில் உருவாக்க உதவுகிறது. இந்த API ஆனது மீண்டும் பயன்படுத்தக்கூடிய மற்றும் தரவுத்தள-அஞ்ஞான குறியீட்டை உருவாக்குவதற்கு மிகவும் பயனுள்ளதாக இருக்கும், ஏனெனில் இது enumகளை இணக்கமான தரவுத்தள வகைகளாக தானாகவே மொழிபெயர்த்து, வகை பிழைகளின் அபாயத்தைக் குறைக்கிறது. இந்த முறை மூலம், வினவல் கட்டுமான செயல்முறை எளிமைப்படுத்தப்பட்டுள்ளது, மேலும் டெவலப்பர்கள் பல்வேறு enum-அடிப்படையிலான வடிகட்டிகளை ஒருங்கிணைக்கப்பட்ட முறையில் கையாளும் நெகிழ்வுத்தன்மையைப் பெறுகின்றனர்.