ప్రిపేర్డ్‌స్టేట్‌మెంట్‌తో పని చేస్తోంది

ప్రకటనల రకాలు

మేము ఇప్పటికే సరళమైన స్టేట్‌మెంట్ ఇంటర్‌ఫేస్‌ని చూశాము . మరియు ఇది పనికి చాలా సరిఅయినది అయినప్పటికీ, సంక్లిష్ట ప్రశ్నలకు ఇది అంతగా సరిపోదు. కొన్ని మూలాధారాలలో, స్టేట్‌మెంట్‌ను ఉపయోగించాల్సిన అవసరం లేదని అభిప్రాయం వ్యక్తం చేయబడింది - బదులుగా మరింత సంక్లిష్టమైన మరియు మరింత ఫంక్షనల్ రిచ్ ఇంటర్‌ఫేస్‌లు అనుకూలంగా ఉంటాయి.

• సిద్ధం చేసిన ప్రకటన
• కాల్ చేయదగిన ప్రకటన

చాలా సహేతుకమైన ప్రశ్న తలెత్తుతుంది - ఈ ఇంటర్‌ఫేస్‌లు ఎందుకు అవసరం? దాన్ని గుర్తించండి.

ముందుగా, మేము ప్రిపేర్డ్‌స్టేట్‌మెంట్ ఇంటర్‌ఫేస్ మరియు ఇతర JDBC ఫీచర్‌లను పరిశీలిస్తాము . మేము తరువాత CallableStatement ఇంటర్‌ఫేస్‌కి వెళ్తాము - దాని ఉపయోగం, మొదట, అంత సాధారణం కాదు, మరియు రెండవది, దాని గురించి ఆలోచించిన ప్రతిదాని తర్వాత, సంభాషణ ఇప్పటికే చాలా చిన్నదిగా చేయవచ్చు.

అలాగే, ప్రిపేర్డ్‌స్టేట్‌మెంట్ అనేది SQL ఇంజెక్షన్ అని పిలువబడే డేటాబేస్ హ్యాకింగ్‌కు ప్రసిద్ధి చెందిన విధానం నుండి గొప్ప సహాయం.

కానీ కొంచెం తరువాత దాని గురించి మరింత.

సిద్ధం చేసిన ప్రకటన

మీరు ప్రిపేర్డ్ స్టేట్‌మెంట్ పేరును అనువదించడానికి ప్రయత్నిస్తే , మీరు “సిద్ధమైన స్టేట్‌మెంట్” వంటిది పొందవచ్చు. ఇక్కడ అత్యంత ముఖ్యమైన పదం "సిద్ధం". "సన్నద్ధత" అంటే ఏమిటి?

మేము ఈ సమస్యను పరిగణలోకి తీసుకునే ముందు, సౌలభ్యం యొక్క కోణం నుండి చాలా ముఖ్యమైన అంశాన్ని చూడాలని నేను ప్రతిపాదిస్తున్నాను, ఇది చాలా తరచుగా జరుగుతుంది. కాబట్టి, కొన్ని అప్లికేషన్‌లలో, మేము కాంటాక్ట్ టేబుల్‌లో సంప్రదింపు డేటాను ఇన్సర్ట్ చేయాలి. దీన్ని చేయడానికి, మేము ఇలాంటి ప్రశ్నను సిద్ధం చేయాలి:

INSERT INTO JC_CONTACT (FIRST_NAME, LAST_NAME, PHONE, EMAIL) VALUES (‘Harry’,'Potter','+79112345678','harry@example.com);

మొదటి చూపులో, ప్రతిదీ చాలా కష్టం మరియు భయానకంగా లేదని అనిపిస్తుంది. పారామితుల నుండి మనకు అవసరమైన స్ట్రింగ్‌ను సేకరించే కోడ్‌ను మేము వ్రాయాలి: మొదటి పేరు, చివరి పేరు, చిరునామా మరియు ఫోన్ నంబర్. అన్ని స్ట్రింగ్ డేటా తప్పనిసరిగా ఒకే కోట్ అక్షరంతో చుట్టుముట్టబడిందని మీరు గుర్తుంచుకోవాలి.

మేము దీన్ని ప్రత్యేక ఫంక్షన్‌లో చేస్తే, మనకు ఇలాంటివి లభిస్తాయి:

public String buildInsert(String firstName,, String lastName, String phone, String email) {
    String sql = "INSERT INTO JC_CONTACT (FIRST_NAME, LAST_NAME, PHONE, EMAIL) “+
             	”VALUES ('" + firstName + "','" + lastName + "','" + phone + "','" + email + ")";
    return sql;
}

మేము ఫారమ్‌లోని పారామీటర్ ఫంక్షన్‌లో మొదటి పేరు, చివరి పేరు, ఫోన్ నంబర్ మరియు చిరునామాను పాస్ చేస్తాము మరియు వాటి నుండి మేము SQL ప్రశ్న స్ట్రింగ్‌ను కంపోజ్ చేస్తాము. కోట్‌లు చిత్రాన్ని కొద్దిగా పాడు చేస్తాయి, కానీ ఇప్పటివరకు ఇది భయానకంగా లేదు.

సరే, సంఖ్యల సంగతేంటి? వాటిని కోట్‌లతో చుట్టుముట్టాల్సిన అవసరం లేదు. ఓపంకీ, ఒక సందర్భంలో మీకు కోట్‌లు అవసరం, మరొక సందర్భంలో మీకు అవసరం లేదు. పరిస్థితి మరింత క్లిష్టంగా మారుతోంది.

ఇప్పుడు మరో సమస్యను జోడిద్దాం - స్ట్రింగ్ లోపల ఒక సాధారణ కోట్ (మరియు ఒకటి కూడా కాదు) ఉంటే? మీరు ముందుగా అటువంటి కోట్‌ల కోసం వెతకాలి మరియు వాటిని ప్రాసెస్ చేయాలి. Mdaaa. ఏదో ఒకవిధంగా మనకు అసౌకర్యంగా అనిపించడం ప్రారంభమవుతుంది.

మేము ఇప్పుడు తేదీ ప్రాసెసింగ్‌ను జోడిస్తే, పని పూర్తిగా బోరింగ్ అవుతుంది - మీరు పెద్ద మొత్తంలో పని చేయాలి. తేదీలు సాధారణంగా అసహ్యకరమైనవి - వేర్వేరు SQL సర్వర్లు తేదీల కోసం వేర్వేరు ఫార్మాట్‌లను అంగీకరిస్తాయి.

కాబట్టి మనం ఏమి చూస్తాము? మేము ప్రశ్న లోపల పారామితులను ఉపయోగించాల్సిన అవసరం ఉంటే, ప్రశ్నను మాన్యువల్‌గా నిర్మించడం చాలా అసహ్యకరమైనది. మరియు అసహ్యకరమైనది మాత్రమే కాదు - నేను బోరింగ్ అని కూడా చెబుతాను. పరిగణించవలసిన పెద్ద సంఖ్యలో కేసులు ఉన్నాయి మరియు ఇది భయంకరమైన బోరింగ్ ఉద్యోగం. ప్రాథమికంగా, అటువంటి సందర్భాలలో ప్రిపేర్డ్‌స్టేట్‌మెంట్ ఇంటర్‌ఫేస్ ప్రతిపాదించబడింది .

ఈ అభ్యర్థన రెండు పనులను చేయడానికి మిమ్మల్ని అనుమతిస్తుంది:

• పారామితులను భర్తీ చేసే స్థలాలను సూచించే అభ్యర్థనను ముందుగానే సిద్ధం చేయండి
• నిర్దిష్ట రకం పారామితులను సెట్ చేసి, ఆపై ఇప్పటికే సెట్ చేసిన పారామితులతో ప్రశ్నను అమలు చేయండి

ప్రిపేర్డ్ స్టేట్మెంట్ ఉదాహరణ

పారామితులను సెట్ చేసే మా ఎంపిక కోసం ప్రిపేర్డ్‌స్టేట్‌మెంట్ నిర్మాణం ఇలా కనిపిస్తుంది:

// Example variables
String firstName = "Harry";
String lastName = "Potter";
String phone = "+12871112233";
String email = "harry@example.com";

// Request with indication of places for parameters in the form of "?"
String sql = "INSERT INTO JC_CONTACT (FIRST_NAME, LAST_NAME, PHONE, EMAIL) VALUES (?, ?, ?, ?)";

// Create a request. The con variable is an object of type Connection
PreparedStatement stmt = con.prepareStatement(sql);

// Set parameters
stmt.setString(1, firstName);
stmt.setString(2, lastName);
stmt.setString(3, phone);
stmt.setString(4, email);

// Execute the request
stmt.executeUpdate();

మీరు గమనిస్తే, ప్రతిదీ చాలా సులభం.

మొదట, SQL ప్రశ్నను వ్రాసేటప్పుడు, పారామితులను భర్తీ చేయవలసిన ప్రదేశాలు ప్రశ్న గుర్తులతో వ్రాయబడతాయి - “?”.

రెండవది, con.prepareStatement()కి కాల్ చేయడం ద్వారా అభ్యర్థన సృష్టించబడుతుంది .

మూడవదిగా, పారామితుల అమరిక సంఖ్య మరియు విలువ యొక్క సూచన ద్వారా వెళుతుంది. శ్రేణులు మరియు సేకరణలతో పని చేస్తున్నప్పుడు మనం ఉపయోగించిన విధంగా పారామితుల సంఖ్య 0 నుండి కాకుండా 1 నుండి ప్రారంభమవుతుందని దయచేసి గమనించండి.

ప్రిపేర్డ్‌స్టేట్‌మెంట్ ఇంటర్‌ఫేస్ స్ట్రింగ్‌లను సెట్ చేసే పద్ధతులను కలిగి ఉంది — setString() , సెట్ నంబర్‌ల కోసం — setInt() , setLong() , setDouble() , తేదీలను సెట్ చేయడానికి — setDate() . మరియు మరింత క్లిష్టమైన రకాలు - ఇది డాక్యుమెంటేషన్లో చూడవచ్చు.

నాల్గవది, ప్రశ్న స్ట్రింగ్‌ను పేర్కొనకుండానే stmt.executeUpdate() కి కాల్ ఇప్పటికే అమలు చేయబడింది.

PreparedStatement తో స్నేహం చేయాలని నేను గట్టిగా సిఫార్సు చేస్తున్నాను - ఇది చాలా ప్రభావవంతమైన సాధనం.