స్థానిక ప్రశ్న

3.1 పరిచయం

మరొక ఉపయోగకరమైన విషయం గురించి నేను మాట్లాడాలనుకుంటున్నాను NativeQuery . మీకు ఇప్పటికే తెలిసినట్లుగా, NativeQueryని ఉపయోగించి, మీరు స్థానిక SQLలో ప్రశ్నలను వ్రాయవచ్చు. అయితే, మరింత ఆసక్తికరమైన విషయం ఏమిటంటే, ప్రశ్న ఫలితాన్ని పొందేటప్పుడు మీరు క్లాస్ మ్యాపింగ్‌ని ఉపయోగించాల్సిన అవసరం లేదు.

నేను మీకు ఒక ఉదాహరణ చూపిస్తాను:

List<Object[]> persons = session.createNativeQuery("SELECT * FROM Person").list();

ఈ ఉదాహరణలో, మేము ప్రశ్న ఫలితాల వరుసలకు సరిపోలే తరగతిని పాస్ చేయము, బదులుగా మేము ఆబ్జెక్ట్ ఆబ్జెక్ట్‌ల శ్రేణిని ఉపయోగిస్తాము.

మీరు పట్టికలో కేవలం రెండు నిలువు వరుసలను ఎంచుకోవాలనుకుంటే ఇది ఉపయోగకరంగా ఉంటుంది. ఉదాహరణ:

List<Object[]> persons = session.createNativeQuery("SELECT id, name FROM Person").list();

for(Object[] person : persons) {
    Number id = (Number) person[0];
    String name = (String) person[1];
}

మీరు ResultSet ఆబ్జెక్ట్‌ని పొందినప్పుడు మరియు దాని అడ్డు వరుసల నుండి డేటాను చదివినప్పుడు ఇది కొంతవరకు JDBC విధానాన్ని పోలి ఉంటుంది.

అయితే, హైబర్నేట్ దీన్ని మరింత నమ్మదగినదిగా చేయడానికి వివిధ మార్గాలను అందిస్తుంది. ఉదాహరణకు, మీరు తీసివేయాలనుకుంటున్న నిలువు వరుసల రకాన్ని పేర్కొనవచ్చు. ఉదాహరణ:

Query<Object[]> query = session.createNativeQuery("SELECT id, name FROM Person");
query.addScalar("id", StandardBasicTypes.LONG);
query.addScalar("name", StandardBasicTypes.STRING);
List<Object[]> persons = query.list();

for(Object[] person : persons) {
    Long id = (Long) person[0];
    String name = (String) person[1];
}

3.2 ఎంటిటీ మ్యాపింగ్

NativeQuery ఫలితాన్ని అన్వయించేటప్పుడు హైబర్నేట్ ఉపయోగించాల్సిన తరగతిని కూడా మీరు స్పష్టంగా పేర్కొనవచ్చు . ఇది వివిధ మార్గాల్లో చేయవచ్చు.

Query<Person> query = session.createNativeQuery("SELECT * FROM Person")
    .addEntity(Person.class);
    .list();

మరియు వాస్తవానికి, మీకు తెలిసిన మంచి పాత ఫార్మాట్:

Query<Person> query = session.createNativeQuery("SELECT * FROM Person", Person.class).list();

మొదటి విధానం స్థానిక హైబర్నేట్ విధానం మరియు రెండవది JPA విధానం. JPA విధానం మరింత సౌకర్యవంతంగా మరియు సంక్షిప్తంగా ఉంటుంది, ఎందుకంటే హైబర్నేట్ చాలా సంవత్సరాలు ఉనికిలో ఉన్న తర్వాత ఈ ప్రమాణం కనుగొనబడింది. మరియు హైబర్నేట్ అభివృద్ధి చెందింది మరియు దాని పాత సంస్కరణలతో అనుకూలతను కొనసాగించడానికి పాత విధానాలకు మద్దతు ఇవ్వవలసి వచ్చింది.

మార్గం ద్వారా, దాని విధానానికి ధన్యవాదాలు, హైబర్నేట్ ప్రశ్న ఫలిత మ్యాపింగ్‌కు ఒక తరగతిని కాకుండా అనేక తరగతులను కనెక్ట్ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది. ఉదాహరణ:

List<Phone> results = session.createNativeQuery(
    "SELECT {ph.*}, {pr.*}" +
    "FROM Phone ph" +
    "JOIN Person pr ON ph.person_id = pr.id")
.addEntity("ph", Phone.class)
.addJoin("pr", "ph.person")
.list();

for (Phone. phone : results) {
           	assertNotNull( phone.getPerson().getName() );
}

NativeQuery ని ఉపయోగించే ఈ విధానం డేటాబేస్ నుండి డేటా ఎంపికను వేగవంతం చేయడానికి ఉపయోగించవచ్చు. మీకు కొన్ని నిలువు వరుసలు అవసరం లేదని మీకు తెలిస్తే, మీరు వాటిని అభ్యర్థనలో వదిలివేయవచ్చు.

హైబర్నేట్ Cache లేదా LazyLoading మెకానిజంను ఉపయోగించాలనుకున్నప్పటికీ, మీరు అన్ని చైల్డ్ ఎంటిటీలను ఒకేసారి లోడ్ చేయవచ్చు . అదనంగా, మీ పిల్లల ఎంటిటీలు డేటాబేస్‌లో అనేక నిలువు వరుసలను కలిగి ఉండవచ్చు మరియు మీరు వాటిలో కొన్నింటిని మాత్రమే ఎంచుకోవచ్చు.

3.3 DTO మ్యాపింగ్

హైబర్నేట్ ఫలితాన్ని మ్యాపింగ్ చేయడానికి ఎంటిటీయేతర తరగతులను ఉపయోగించడానికి కూడా మిమ్మల్ని అనుమతిస్తుంది. ఎటువంటి ఉల్లేఖనాలు లేని తరగతులు మరియు ఏ పట్టికలకు మ్యాప్ చేయబడలేదు.

ఉదాహరణ:

public class PersonSummaryDTO {
    private Number id;
    private String name;

    public Number getId() {
    	return id;
    }

    public void setId(Number id) {
    	this.id = id;
    }

    public String getName() {
    	return name;
    }

    public void setName(String name) {
    	this.name = name;
	}
}

List<PersonSummaryDTO> dtos = session.createNativeQuery(
    "SELECT p.id as \"id\", p.name as \"name\" FROM Person p")
.setResultTransformer(Transformers.aliasToBean(PersonSummaryDTO.class) )
.list();

PersonSummaryDTO క్లాస్‌లో ఉల్లేఖనాలు లేనందున, SQL ప్రశ్నలోని నిలువు వరుసల పేర్లు ఖచ్చితంగా PersonSummaryDTO క్లాస్ ఫీల్డ్‌ల పేర్లతో సరిపోలాలి.

మీరు మీ అప్లికేషన్ రీడ్-ఓన్లీ మోడ్‌లో మాత్రమే కనెక్ట్ చేయబడిన బాహ్య డేటాబేస్ నుండి డేటాను చదువుతున్నట్లయితే ఇది చాలా ఉపయోగకరంగా ఉంటుంది. అంటే, 50+ నిలువు వరుసలను కలిగి ఉన్న పట్టికలకు మీకు యాక్సెస్ ఇవ్వబడింది, అవి ఎంపికను వేగవంతం చేయడానికి డేటాను సాధారణీకరించిన రూపంలో నిల్వ చేస్తాయి.

లేదా ఎవరైనా తరగతి సోపానక్రమాన్ని ఒకే టేబుల్‌లో నిల్వ చేయాలని నిర్ణయించుకున్నారని అనుకుందాం మరియు ఐదేళ్లలో ఈ టేబుల్ డెవిల్ అతని కాలు విరిగిపోయేంతగా పెరిగింది. మీరు ఈ పట్టిక (ఐడి మరియు వినియోగదారు పేరు) నుండి రెండు నిలువు వరుసలను ఎంచుకోవాలి మరియు వాటిని క్లయింట్‌కు ఇవ్వాలి.

మీరు అర్థం చేసుకున్నారని నేను అనుకుంటున్నాను, కానీ మీరు ఈ అంశంపై లోతుగా డైవ్ చేయాలనుకుంటే, మీరు లింక్‌లో మరింత చదవవచ్చు:

స్థానిక SQL ప్రశ్నలు