మీకు "ఎక్కడ నుండి a = b నుండి c" లేదా "a = b నుండి ఇక్కడ ఎంచుకోండి =" అవసరమా?

మీరు నాలాగే ఉంటే, మీరు అంగీకరిస్తారు: SQL అనేది మొదటి చూపులో తేలికగా అనిపించే వాటిలో ఒకటి (ఇది ఇంగ్లీషులో చదివినట్లుగా ఉంటుంది!), కానీ కొన్ని కారణాల వల్ల మీరు సరైన వాక్యనిర్మాణాన్ని కనుగొనడానికి ప్రతి సాధారణ ప్రశ్నను గూగుల్ చేయాలి.

ఆపై చేరడం, అగ్రిగేషన్‌లు, సబ్‌క్వరీలు ప్రారంభమవుతాయి మరియు ఇది పూర్తిగా అర్ధంలేనిదిగా మారుతుంది. ఇది ఇలా కనిపిస్తుంది:

సభ్యులను ఎంచుకోండి. మొదటి పేరు || "" || members.lastname AS "పూర్తి పేరు" నుండి సభ్యులపై సభ్యులపై సభ్యులై ఉంటారు. ) పుస్తకాల నుండి)) సభ్యుల ద్వారా మొదటి పేరు, మొదటి పేరు, సభ్యులు. చివరి పేరు;

Bue! ఇది SQL ని చూడటం ఇదే మొదటిసారి అయితే, ఇది ఏదైనా కొత్త వ్యక్తిని లేదా ఇంటర్మీడియట్ డెవలపర్‌ని కూడా భయపెడుతుంది. కానీ ఇది అంత చెడ్డది కాదు.

సహజమైనది ఏమిటో గుర్తుంచుకోవడం సులభం, మరియు ఈ ట్యుటోరియల్ సహాయంతో, కొత్తవారికి SQL ఎంట్రీ కోసం ప్రవేశాన్ని తగ్గించాలని మరియు అనుభవం ఉన్నవారికి SQL లో తాజా రూపాన్ని అందించాలని నేను ఆశిస్తున్నాను.

వివిధ డేటాబేస్‌లలో SQL సింటాక్స్ దాదాపు ఒకే విధంగా ఉన్నప్పటికీ, ఈ వ్యాసం ప్రశ్నల కోసం PostgreSQL ని ఉపయోగిస్తుంది. కొన్ని ఉదాహరణలు MySQL మరియు ఇతర డేటాబేస్‌లలో పని చేస్తాయి.

1. మూడు మేజిక్ పదాలు

SQL లో అనేక కీలకపదాలు ఉన్నాయి, కానీ దాదాపు ప్రతి ప్రశ్నలో ఎంచుకోండి, ఎక్కడ నుండి మరియు ఎక్కడ కనిపిస్తాయి. కొద్దిసేపటి తరువాత, ఈ మూడు పదాలు డేటాబేస్ ప్రశ్నలను రూపొందించడంలో అత్యంత ప్రాథమిక అంశాలను సూచిస్తాయని మరియు ఇతర, మరింత క్లిష్టమైన ప్రశ్నలు వాటి పైన యాడ్-ఆన్‌లు అని మీరు గ్రహిస్తారు.

2. మా ఆధారం

ఈ ఆర్టికల్‌లో ఉదాహరణగా మనం ఉపయోగిస్తున్న డేటాబేస్‌ను చూద్దాం:

మాకు పుస్తక గ్రంథాలయం మరియు వ్యక్తులు ఉన్నారు. జారీ చేసిన పుస్తకాల అకౌంటింగ్ కోసం ప్రత్యేక పట్టిక కూడా ఉంది.

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

3. సాధారణ అభ్యర్థన

ఒక సాధారణ ప్రశ్నతో ప్రారంభిద్దాం: మాకు అవసరం పేర్లుమరియు ఐడెంటిఫైయర్‌లు(id) రచయిత "డాన్ బ్రౌన్" రాసిన అన్ని పుస్తకాల

అభ్యర్థన ఇలా ఉంటుంది:

రచయిత = "డాన్ బ్రౌన్" నుండి పుస్తకాల నుండి శీర్షిక "ఐడి" ఎంచుకోండి;

మరియు ఫలితం ఇలా ఉంటుంది:

id	శీర్షిక
2	కోల్పోయిన చిహ్నం
4	నరకము

చాలా సులభం. ఏమి జరుగుతుందో అర్థం చేసుకోవడానికి అభ్యర్థనను చూద్దాం.

3.1 నుండి - మేము డేటాను ఎక్కడ నుండి పొందుతాము

ఇది ఇప్పుడు స్పష్టంగా అనిపించవచ్చు, కానీ మేము జాయిన్‌లు మరియు సబ్‌క్వరీలకు చేరుకున్నప్పుడు FROM చాలా ముఖ్యమైనది.

వ్యతిరేకంగా ప్రశ్నించడానికి పట్టిక నుండి పాయింట్లు. ఇది ఇప్పటికే ఉన్న పట్టిక (పై ఉదాహరణలో ఉన్నట్లుగా) లేదా జాయిన్స్ లేదా సబ్‌క్వరీస్ ద్వారా ఫ్లైలో సృష్టించబడిన టేబుల్ కావచ్చు.

3.2 ఎక్కడ - ఏ డేటాను చూపించాలి

ఎక్కడ కేవలం ఫిల్టర్ లాగా ప్రవర్తిస్తుంది తీగలనుమేము అవుట్‌పుట్ చేయాలనుకుంటున్నాము. మా విషయంలో, రచయిత కాలమ్‌లోని విలువ “డాన్ బ్రౌన్” ఉన్న పంక్తులను మాత్రమే చూడాలనుకుంటున్నాము.

3.3 ఎంచుకోండి - డేటాను ఎలా ప్రదర్శించాలి

ఇప్పుడు మనకు అవసరమైన పట్టిక నుండి అవసరమైన అన్ని నిలువు వరుసలు ఉన్నాయి, ఈ డేటాను ఎలా ప్రదర్శించాలో మనం నిర్ణయించుకోవాలి. మా విషయంలో, పుస్తకాల టైటిల్స్ మరియు ఐడెంటిఫైయర్‌లు మాత్రమే అవసరం, కాబట్టి ఇది మనం మరియు ఎంచుకోండి SELECT ఉపయోగించి. అదే సమయంలో, మీరు AS ఉపయోగించి కాలమ్ పేరు మార్చవచ్చు.

మొత్తం ప్రశ్నను సాధారణ రేఖాచిత్రంతో చూడవచ్చు:

4. కనెక్షన్లు (జాయిన్స్)

ఇప్పుడు మేము లైబ్రరీ నుండి తీసుకున్న డాన్ బ్రౌన్ యొక్క అన్ని పుస్తకాల శీర్షికలను (తప్పనిసరిగా ప్రత్యేకంగా కాదు) చూడాలనుకుంటున్నాము, మరియు ఈ పుస్తకాలను ఎప్పుడు తిరిగి ఇవ్వాలి:

Books.title AS "టైటిల్", అప్పులు.రెటర్డేట్ AS "రిటర్న్ డేట్" నుండి రుణాలు తీసుకోవడంలో పుస్తకాలలో చేరండి. Bookid = పుస్తకాలు

ఫలితం:

శీర్షిక	తిరిగి వచ్చు తేదీ
కోల్పోయిన చిహ్నం	2016-03-23 00:00:00
నరకము	2016-04-13 00:00:00
కోల్పోయిన చిహ్నం	2016-04-19 00:00:00

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

అప్పులు పుస్తకాలలో చేరండి. అటువంటి విలీనం ఫలితంగా ఉంటుంది:

ఆపై మేము ఈ పట్టికను పై ఉదాహరణలో ఉన్న విధంగానే ప్రశ్నిస్తాము. దీని అర్థం టేబుల్స్‌లో చేరినప్పుడు, దాన్ని ఎలా జాయిన్ చేయాలనే దాని గురించి మాత్రమే మీరు ఆందోళన చెందాలి. ఆపై అభ్యర్థన పాయింట్ 3 నుండి "సాధారణ అభ్యర్థన" విషయంలో స్పష్టంగా కనిపిస్తుంది.

కొంచెం సంక్లిష్టమైన రెండు-టేబుల్ జాయిన్ ప్రయత్నించండి.

ఇప్పుడు మేము రచయిత పుస్తకం "డాన్ బ్రౌన్" లైబ్రరీ నుండి తీసుకున్న వ్యక్తుల పేర్లను పొందాలనుకుంటున్నాము.

ఈసారి, దిగువ నుండి పైకి వెళ్దాం:

దశ 1- మేము డేటాను ఎక్కడ నుండి పొందుతాము? మేము కోరుకున్న ఫలితాన్ని పొందడానికి, "రుణాలు" పట్టికతో "సభ్యుడు" మరియు "పుస్తకాలు" పట్టికలలో చేరాలి. జాయిన్ విభాగం ఇలా కనిపిస్తుంది:

అప్పులు చేరండి

కనెక్షన్ ఫలితం లింక్‌లో చూడవచ్చు.

దశ 2- మేము ఏ డేటాను చూపుతున్నాము? పుస్తక రచయిత "డాన్ బ్రౌన్" ఉన్న డేటాపై మాత్రమే మాకు ఆసక్తి ఉంది

ఎక్కడ పుస్తకాలు. రచయిత = "డాన్ బ్రౌన్"

దశ 3- మేము డేటాను ఎలా ప్రదర్శిస్తాము? ఇప్పుడు డేటా స్వీకరించబడింది, మీరు పుస్తకాలను తీసుకున్న వారి పేరు మరియు ఇంటిపేరును ప్రదర్శించాలి:

సభ్యులను ఎంచుకోండి. మొదటి పేరు AS "మొదటి పేరు", members.lastname AS "చివరి పేరు"

సూపర్! ఇది మూడు భాగాలను కలపడానికి మరియు మాకు అవసరమైన అభ్యర్థనను చేయడానికి మాత్రమే మిగిలి ఉంది:

మెంబర్‌లను ఎంచుకోండి. మొదటి పేరు "మొదటి పేరు", members.lastname AS "చివరి పేరు" అప్పుల నుండి పుస్తకాలలో చేరండి.

ఏది మాకు ఇస్తుంది:

మొదటి పేరు	చివరి పేరు
మైక్	విల్లీస్
ఎల్లెన్	హోర్టన్
ఎల్లెన్	హోర్టన్

బాగా! కానీ పేర్లు పునరావృతమవుతాయి (అవి ప్రత్యేకమైనవి కావు). మేము దీనిని త్వరలో పరిష్కరిస్తాము.

5. అగ్రిగేషన్

స్థూలంగా చెప్పాలంటే, బహుళ వరుసలను ఒకటిగా మార్చడానికి అగ్రిగేషన్‌లు అవసరం... అదే సమయంలో, అగ్రిగేషన్ సమయంలో, వివిధ కాలమ్‌ల కోసం విభిన్న లాజిక్ ఉపయోగించబడుతుంది.

నకిలీ పేర్లు కనిపించే మా ఉదాహరణతో కొనసాగిద్దాం. ఎల్లెన్ హోర్టన్ ఒకటి కంటే ఎక్కువ పుస్తకాలను అరువు తీసుకున్నట్లు చూడవచ్చు, కానీ ఈ సమాచారాన్ని చూపించడానికి ఇది ఉత్తమ మార్గం కాదు. మరొక అభ్యర్థన చేయవచ్చు:

సభ్యులను ఎన్నుకోండి. మొదటి పేరు AS "మొదటి పేరు", సభ్యులు. చివరి పేరు AS "చివరి పేరు", లెక్క . సభ్యుడు ఎక్కడ పుస్తకాలు.అథర్ = "డాన్ బ్రౌన్" సభ్యుల ద్వారా గ్రూప్ చేయండి. మొదటి పేరు, సభ్యులు. చివరి పేరు;

ఇది మనకు కావలసిన ఫలితాన్ని ఇస్తుంది:

మొదటి పేరు	చివరి పేరు	అప్పు తీసుకున్న పుస్తకాల సంఖ్య
మైక్	విల్లీస్	1
ఎల్లెన్	హోర్టన్	2

దాదాపు అన్ని అగ్రిగేషన్‌లు గ్రూప్ బై క్లాజ్‌తో వస్తాయి. ఈ విషయం ప్రశ్న ద్వారా తిరిగి పొందగలిగే పట్టికను పట్టికల సమూహాలుగా మారుస్తుంది. ప్రతి సమూహం GROUP BY లో మేము పేర్కొన్న కాలమ్ కోసం ప్రత్యేకమైన విలువకు (లేదా విలువల సమూహం) అనుగుణంగా ఉంటుంది. మా ఉదాహరణలో, మేము మునుపటి వ్యాయామం నుండి ఫలితాన్ని వరుస సమూహంగా మారుస్తున్నాము. మేము గణనతో కూడా కలుపుతాము, ఇది బహుళ వరుసలను పూర్ణాంక విలువగా మారుస్తుంది (మా విషయంలో, ఇది వరుసల సంఖ్య). అప్పుడు ఈ విలువ ప్రతి సమూహానికి కేటాయించబడుతుంది.

ఫలితంలోని ప్రతి అడ్డు వరుస ప్రతి సమూహం యొక్క సంకలనం యొక్క ఫలితం.

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

పై ఉదాహరణలో, కౌంట్ ఫంక్షన్ అన్ని పంక్తులను ప్రాసెస్ చేసింది (మేము పంక్తుల సంఖ్యను లెక్కిస్తున్నందున). మొత్తం లేదా గరిష్ఠం వంటి ఇతర విధులు పేర్కొన్న స్ట్రింగ్‌లను మాత్రమే ప్రాసెస్ చేస్తాయి. ఉదాహరణకు, ప్రతి రచయిత వ్రాసిన పుస్తకాల సంఖ్యను మనం తెలుసుకోవాలనుకుంటే, మనకు ఇలాంటి ప్రశ్న అవసరం:

రచయిత నుండి పుస్తకాల నుండి రచయిత, మొత్తాన్ని (స్టాక్) ఎంచుకోండి;

ఫలితం:

రచయిత	మొత్తం
రాబిన్ శర్మ	4
డాన్ బ్రౌన్	6
జాన్ గ్రీన్	3
అమిష్ త్రిపాఠి	2

ఇక్కడ, సమ్ ఫంక్షన్ స్టాక్ కాలమ్‌ని మాత్రమే ప్రాసెస్ చేస్తుంది మరియు ప్రతి గ్రూపులోని అన్ని విలువల మొత్తాన్ని లెక్కిస్తుంది.

6. ఉప ప్రశ్నలు

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

6.1 రెండు డైమెన్షనల్ టేబుల్

బహుళ నిలువు వరుసలను తిరిగి ఇచ్చే ప్రశ్నలు ఉన్నాయి. చివరి అగ్రిగేషన్ వ్యాయామం నుండి వచ్చిన ప్రశ్న మంచి ఉదాహరణ. సబ్‌క్వరీగా, ఇది కొత్త పట్టికలకు వ్యతిరేకంగా మరొక పట్టికను అందిస్తుంది. మునుపటి వ్యాయామం కొనసాగిస్తూ, "రాబిన్ శర్మ" రచయిత వ్రాసిన పుస్తకాల సంఖ్యను మనం తెలుసుకోవాలనుకుంటే, సాధ్యమయ్యే మార్గాలలో ఒకటి సబ్‌క్వరీలను ఉపయోగించడం:

రచయిత నుండి ఎంపిక చేసుకోండి (రచయిత నుండి మొత్తం పుస్తకాన్ని సేకరించండి (రచయిత నుండి మొత్తం)

ఫలితం:

ఇలా వ్రాయవచ్చు: ["రాబిన్ శర్మ", "డాన్ బ్రౌన్"]

2. ఇప్పుడు ఈ ఫలితాన్ని కొత్త ప్రశ్నలో ఉపయోగిద్దాం:

శీర్షికను ఎంచుకోండి, పుస్తకాల నుండి పుస్తకాన్ని బుక్ చేయండి (రచయిత నుండి రచయితను ఎంచుకోండి (రచయిత నుండి మొత్తం పుస్తకాన్ని సేకరించండి)

ఫలితం:

శీర్షిక	బుకీడ్
కోల్పోయిన చిహ్నం	2
మీరు చనిపోయినప్పుడు ఎవరు ఏడ్చుతారు?	3
నరకము	4

ఇది ఇదే:

రచయిత పేరు ("రాబిన్ శర్మ", "డాన్ బ్రౌన్") నుండి పుస్తకాలను బుక్ చేయండి

6.3 వ్యక్తిగత విలువలు

కేవలం ఒక అడ్డు వరుస మరియు ఒక నిలువు వరుసకు సంబంధించిన ప్రశ్నలు ఉన్నాయి. అవి స్థిరమైన విలువలుగా పరిగణించబడతాయి మరియు పోలిక ఆపరేటర్‌ల వంటి విలువలు ఉపయోగించిన ప్రతిచోటా ఉపయోగించవచ్చు. వాటిని రెండు డైమెన్షనల్ టేబుల్స్ లేదా సింగిల్-ఎలిమెంట్ శ్రేణులుగా కూడా ఉపయోగించవచ్చు.

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

సగటును ఈ విధంగా పొందవచ్చు:

పుస్తకాల నుండి సగటు (స్టాక్) ఎంచుకోండి;

ఇది మాకు ఇస్తుంది:

7. కార్యకలాపాలు వ్రాయండి

చాలా క్లిష్టమైన రీడ్‌లతో పోలిస్తే చాలా డేటాబేస్ వ్రాతలు చాలా సూటిగా ఉంటాయి.

7.1 నవీకరణ

UPDATE ప్రశ్నకు వాక్యనిర్మాణం చదవడానికి సంబంధించిన ప్రశ్నకు సమానంగా ఉంటుంది. ఒకే తేడా ఏమిటంటే, SELECT కాలమ్‌లను ఎంచుకోవడానికి బదులుగా, మేము SET విలువలను సెట్ చేస్తాము.

డాన్ బ్రౌన్ పుస్తకాలన్నీ పోయినట్లయితే, మీరు పరిమాణ విలువను రీసెట్ చేయాలి. దీని కోసం అభ్యర్థన ఇలా ఉంటుంది:

సెట్ స్టాక్ పుస్తకాలను అప్‌డేట్ చేయండి = 0 రచయిత = "డాన్ బ్రౌన్";

మునుపటిలాగే ఎక్కడ చేస్తుంది: అడ్డు వరుసలను ఎంచుకుంటుంది. చదివేటప్పుడు ఉపయోగించిన SELECT కి బదులుగా, మేము ఇప్పుడు SET ని ఉపయోగిస్తాము. అయితే, ఇప్పుడు మీరు కాలమ్ పేరు మాత్రమే కాకుండా, ఎంచుకున్న అడ్డు వరుసలలో ఈ కాలమ్ కోసం కొత్త విలువను కూడా పేర్కొనాలి.

7.2 తొలగించు

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

రచయిత నుండి పుస్తకాలను తొలగించండి = "డాన్ బ్రౌన్";

7.3 చొప్పించు

ఇతర రకాల ప్రశ్నలకు భిన్నంగా ఉండే ఏకైక విషయం ఇన్సర్ట్. ఫార్మాట్:

X (a, b, c) విలువలు (x, y, z) చేర్చండి;

ఇక్కడ a, b, c అనేవి నిలువు వరుసల పేర్లు, మరియు x, y మరియు z లు ఒకే వరుసలో ఆ నిలువు వరుసలలో చేర్చాల్సిన విలువలు. ప్రాథమికంగా అంతే.

ఒక నిర్దిష్ట ఉదాహరణను చూద్దాం. మొత్తం "పుస్తకాలు" పట్టికలో జనాదరణ పొందిన ఒక ఇన్సర్ట్ ప్రశ్న ఇక్కడ ఉంది:

పుస్తకాలలో చేర్చండి (బుకీడ్, శీర్షిక, రచయిత, ప్రచురించిన, స్టాక్) విలువలు (1, "ఇక్ష్వాకు సియోన్", "అమిష్ త్రిపాఠి", "06-22-2015", 2), (2, "ది లాస్ట్ సింబల్", " డాన్ బ్రౌన్ "," 07-22-2010 ", 3), (3," మీరు చనిపోయినప్పుడు ఎవరు ఏడుస్తారు? "," రాబిన్ శర్మ "," 06-15-2006 ", 4), (4," ఇన్‌ఫెర్నో " , "డాన్ బ్రౌన్", "05-05-2014", 3), (5, "ది ఫాల్ట్ ఇన్ అవర్ స్టార్స్", "జాన్ గ్రీన్", "01-03-2015", 3);

8. ధృవీకరణ

మేము ముగింపుకు వచ్చాము, నేను ఒక చిన్న పరీక్షను ప్రతిపాదిస్తున్నాను. వ్యాసం ప్రారంభంలోనే ఆ అభ్యర్థనను చూడండి. మీరు దాన్ని గుర్తించగలరా? దీన్ని క్లాక్‌లు ద్వారా ఎంచుకోండి, ఎక్కడ నుండి, గ్రూప్‌గా విభజించి, సబ్‌క్వరీల యొక్క వ్యక్తిగత భాగాలను పరిగణించండి.

ఇక్కడ ఇది మరింత చదవగలిగే రూపంలో ఉంది:

సభ్యులను ఎంచుకోండి. మొదటి పేరు || "" || members.lastname AS "పూర్తి పేరు" నుండి సభ్యులపై సభ్యులపై సభ్యులై ఉంటారు. ) పుస్తకాల నుండి)) సభ్యుల ద్వారా మొదటి పేరు, సభ్యులు. చివరి పేరు;

ఈ ప్రశ్న లైబ్రరీ నుండి సగటు మొత్తం కంటే ఎక్కువ ఉన్న పుస్తకాన్ని తనిఖీ చేసిన వ్యక్తుల జాబితాను అందిస్తుంది.

ఫలితం:

పూర్తి పేరు
లిడా టైలర్

మీరు ఎటువంటి సమస్యలు లేకుండా దాన్ని గుర్తించగలిగారని నేను ఆశిస్తున్నాను. కానీ కాకపోతే, నేను ఈ పోస్ట్‌ను మెరుగుపరచడానికి మీ వ్యాఖ్యలు మరియు అభిప్రాయాన్ని నేను అభినందిస్తున్నాను.

ఈ అధ్యాయంలో, ఇతర భాషలలో వ్రాసిన ప్రోగ్రామ్‌లను విస్తరించడానికి sql ఎలా ఉపయోగించబడుతుందో మీరు నేర్చుకుంటారు. SQL యొక్క విధానేతర స్వభావం చాలా శక్తివంతమైనదిగా చేస్తుంది, అదే సమయంలో అది దానిపై విధిస్తుంది పెద్ద సంఖ్యఆంక్షలు. ఈ పరిమితులను అధిగమించడానికి, మీరు SQL ను ఒకటి లేదా మరొక విధాన భాషలో వ్రాసిన ప్రోగ్రామ్‌లలో చేర్చవచ్చు (నిర్దిష్ట అల్గోరిథంతో). మా ఉదాహరణల కోసం, మేము పాస్కల్‌ని ఎంచుకున్నాము, ఈ భాష ప్రారంభకులకు అర్థం చేసుకోవడానికి సులభమైనది, మరియు ANSI సెమీ-అధికారిక ప్రమాణాన్ని కలిగి ఉన్న భాషలలో పాస్కల్ కూడా ఒకటి.

SQL గూడు అంటే ఏమిటి

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

SQL ఎందుకు చేర్చబడింది?

SQL ఏమి చేయగలదో చూపించడానికి మేము కొంత సమయం గడిపినప్పటికీ, మీరు అనుభవజ్ఞుడైన ప్రోగ్రామర్ అయితే, ప్రోగ్రామ్‌లను వ్రాసేటప్పుడు అది అంతగా ఉపయోగపడదని మీరు గమనించవచ్చు. అత్యంత స్పష్టమైన పరిమితి ఏమిటంటే, SQL ఒకేసారి బ్యాచ్ ఆదేశాలను అమలు చేయగలదు, ఇంటరాక్టివ్ SQL ప్రాథమికంగా ఒకేసారి ఒక ఆదేశాన్ని అమలు చేస్తుంది. తార్కిక నిర్మాణాల రకాలు if ... అప్పుడు ("if ... then"), for ... do ("to ... execute") మరియు అయితే ... పునరావృతం ("అయితే ... పునరావృతం") - చాలా కంప్యూటర్ ప్రోగ్రామ్‌ల నిర్మాణాల కోసం ఉపయోగిస్తారు, అవి ఇక్కడ లేవు, కాబట్టి మరొక చర్య ఫలితంగా ఒక చర్యను ఎలా చేయాలో, ఎలా చేయాలో, లేదా ఎంత సమయం తీసుకోవాలో మీరు నిర్ణయించుకోలేరు. అదనంగా, ఇంటరాక్టివ్ SQL వాటిని పట్టికలో ఉంచడం, ప్రశ్నలను ఉపయోగించి ఉంచడం లేదా పంపిణీ చేయడం మరియు వాటిని కొన్ని పరికరానికి అవుట్‌పుట్ చేయడం వంటివి కాకుండా ఇతర విలువలతో ఎక్కువ చేయలేవు.

అయితే, ఈ ప్రాంతాలలో మరింత సాంప్రదాయ భాషలు బలంగా ఉన్నాయి. ప్రోగ్రామర్ డేటాను ప్రాసెస్ చేయడం ప్రారంభించడానికి, మరియు దాని ఫలితాల ఆధారంగా, ఈ చర్య లేదా మరొకటి చేయాలా వద్దా అని నిర్ణయించడానికి లేదా నిర్దిష్ట షరతు నెరవేరే వరకు చర్యను పునరావృతం చేయడానికి, తార్కిక మార్గాలు మరియు లూప్‌లను సృష్టించడం కోసం అవి రూపొందించబడ్డాయి. విలువలు వేరియబుల్స్‌లో నిల్వ చేయబడతాయి, వీటిని ఎన్ని కమాండ్‌లతో అయినా ఉపయోగించవచ్చు మరియు మార్చవచ్చు. ఇది ఒక ఫైల్ నుండి ఈ ఆదేశాలను ఇన్‌పుట్ చేయడానికి లేదా అవుట్‌పుట్ చేయడానికి వినియోగదారులను నిర్దేశించే సామర్థ్యాన్ని మరియు సంక్లిష్ట మార్గాల్లో అవుట్‌పుట్‌ను ఫార్మాట్ చేసే సామర్థ్యాన్ని అందిస్తుంది (సంఖ్యా డేటాను చార్ట్‌లుగా మార్చడం వంటివి). గూడు SQL యొక్క ఉద్దేశ్యం ఈ సామర్ధ్యాలను కలపడం, SQL ని ఉపయోగించి డేటాబేస్ను పరిష్కరించే సంక్లిష్టమైన విధానపరమైన ప్రోగ్రామ్‌లను రూపొందించడానికి మిమ్మల్ని అనుమతిస్తుంది - నిర్మాణాత్మకతను కొనసాగిస్తూ, ఆ డేటా నిర్మాణం వైపు ఆధారపడని విధానపరమైన భాషలో పట్టికలలో సంక్లిష్ట చర్యలను తొలగించడానికి మిమ్మల్ని అనుమతిస్తుంది. విధానపరమైన భాష యొక్క కఠినత.

SQL న్యూట్రిషన్ ఎలా పూర్తయింది.

SQL ఆదేశాలు ప్రధాన ప్రోగ్రామ్ యొక్క సోర్స్ కోడ్‌లో ఉంచబడ్డాయి, ముందుగా EXEC SQL (EXECute SQL). కిందివి కొన్ని ఆదేశాలను ఇన్‌స్టాల్ చేస్తాయి, ఇవి సమూహ SQL ఫారమ్‌కు ప్రత్యేకమైనవి మరియు ఈ అధ్యాయంలో ప్రదర్శించబడతాయి. ఖచ్చితంగా చెప్పాలంటే, ANSI ప్రమాణం సమూహంలోని SQL కి మద్దతు ఇవ్వదు. ఇది ఒక కాన్సెప్ట్‌కు మద్దతు ఇస్తుంది - ఒక మాడ్యూల్, ఇది మరింత ఖచ్చితంగా SQL విధానాల కాల్ చేయదగిన సెట్, మరొక భాషలో గూడు కాదు. SQL గూడు సింటాక్స్ యొక్క అధికారిక నిర్వచనంలో SQL గూడు పెట్టగల ప్రతి భాష యొక్క అధికారిక వాక్యనిర్మాణాన్ని విస్తరించడం ఉంటుంది, ఇది ANSI నివారించే చాలా పొడవైన మరియు కృతజ్ఞత లేని పని. ఏదేమైనా, ANSI నాలుగు అనుబంధాలకు (ప్రమాణంలో భాగం కాదు) నాలుగు భాషలకు SQL గూడు వాక్యనిర్మాణాన్ని అందిస్తుంది: COBOL, PASCAL, FORTRAN మరియు PL / 1. సి భాష కూడా ఇతర భాషలతో పాటు విస్తృతంగా మద్దతు ఇస్తుంది. మీరు వేరే భాషలో వ్రాసిన ప్రోగ్రామ్‌లో SQL ఆదేశాలను చొప్పించినప్పుడు, మీరు చివరకు కంపైల్ చేయడానికి ముందు తప్పనిసరిగా ముందుగా సంకలనం చేయాలి. ప్రీకాంపైలర్ (లేదా ప్రిప్రాసెసర్) అనే ప్రోగ్రామ్ మీ ప్రోగ్రామ్ యొక్క టెక్స్ట్‌ను చూస్తుంది మరియు SQL ఆదేశాలను అంతర్లీన భాష ద్వారా ఉపయోగపడే రూపంలో అనువదిస్తుంది.

ప్రోగ్రామ్‌ను సోర్స్ నుండి ఎగ్జిక్యూటబుల్ కోడ్‌గా మార్చడానికి మీరు రెగ్యులర్ ట్రాన్స్‌లేటర్‌ను ఉపయోగిస్తారు. ANSI నిర్వచించిన మాడ్యులర్ లాంగ్వేజ్ విధానం ప్రకారం, ప్రధాన ప్రోగ్రామ్ SQL విధానాలను పిలుస్తుంది. దినచర్యలు ప్రధాన ప్రోగ్రామ్ నుండి పారామితులను ఎంచుకుంటాయి మరియు ఇప్పటికే ప్రాసెస్ చేయబడిన విలువలను ప్రధాన ప్రోగ్రామ్‌కు తిరిగి ఇస్తాయి. ఒక మాడ్యూల్ ఎన్ని విధానాలను అయినా కలిగి ఉంటుంది, వీటిలో ప్రతి ఒక్కటి ఒకే SQL ఆదేశాన్ని కలిగి ఉంటుంది. ఆలోచన ఏమిటంటే, విధానాలు గూడులో ఉన్న భాషలోని విధానాల వలెనే పని చేయగలవు (అయినప్పటికీ వివిధ భాషల డేటా రకాల్లో తేడాల కారణంగా మాడ్యూల్ ఇప్పటికీ ప్రాథమిక భాషను గుర్తించాల్సి ఉంది). మాడ్యూల్స్ ఇప్పటికే బాగా నిర్వచించబడినట్లుగా SQL గూడును అమలు చేయడం ద్వారా అమలులు ప్రమాణానికి అనుగుణంగా ఉంటాయి. ఈ ప్రయోజనం కోసం, ప్రీకాంపైలర్ యాక్సెసర్ అనే మాడ్యూల్‌ను సృష్టిస్తుంది. ఇచ్చిన ప్రోగ్రామ్ కోసం ఎన్ని SQL విధానాలను కలిగి ఉన్న ఒక మాడ్యూల్ మాత్రమే ఉంటుంది. SQL స్టేట్‌మెంట్‌లను నేరుగా ప్రధాన కోడ్‌లో ఉంచడం మాడ్యూల్స్‌ను సృష్టించడం కంటే సరళమైనది మరియు మరింత ఆచరణాత్మకమైనది. SQL అటాచ్‌మెంట్‌ను ఉపయోగించే ప్రతి ప్రోగ్రామ్ రన్ టైమ్‌లో యాక్సెస్ ID తో అనుబంధించబడుతుంది. ప్రోగ్రామ్‌తో అనుబంధించబడిన యాక్సెస్ ID ప్రోగ్రామ్‌లో SQL కార్యకలాపాలు నిర్వహించడానికి పూర్తి అధికారాలను కలిగి ఉండాలి. సాధారణంగా, పొందుపరిచిన SQL ప్రోగ్రామ్ డేటాబేస్‌లో నమోదు చేయబడుతుంది, అలాగే ప్రోగ్రామ్‌ను అమలు చేస్తున్న వినియోగదారు. మరింత వివరంగా, ఇది డిజైనర్ ద్వారా నిర్ణయించబడుతుంది, అయితే మీ ప్రోగ్రామ్‌లో కనెక్ట్ కమాండ్ లేదా ఇలాంటివి చేర్చడం మంచిది.

SQL లో బేసిక్ లాంగ్వేజ్ వేరియబుల్స్ ఉపయోగించడం

మీ ప్రోగ్రామ్‌ల SQL మరియు బేస్ లాంగ్వేజ్ భాగాలు ఒకదానితో ఒకటి కమ్యూనికేట్ చేసుకునే ప్రధాన మార్గం వేరియబుల్ విలువల ద్వారా. అది సహజం వివిధ భాషలువేరియబుల్స్ కోసం వివిధ డేటా రకాలను గుర్తించండి. ANSI నాలుగు ప్రధాన భాషలకు SQL సమానమైన వాటిని నిర్వచించింది - PL / 1, పాస్కల్, COBOL మరియు FORTRAN; ఈ వివరాలన్నీ అనుబంధం B లో వివరించబడ్డాయి. ఇతర భాషలకు సమానమైనవి డిజైనర్ ద్వారా నిర్వచించబడ్డాయి. DATE వంటి రకాలు ANSI ద్వారా గుర్తించబడలేదని గమనించండి; అందువల్ల ANSI ప్రమాణంలో హోస్ట్ భాషలకు సమానమైన డేటాటైప్ లేదు. మాత్రికలు వంటి మరింత సంక్లిష్టమైన కోర్ లాంగ్వేజ్ డేటాటైప్‌లకు SQL సమానమైనవి లేవు. మీరు విలువ వ్యక్తీకరణలను ఉపయోగించే ప్రతిచోటా ప్రధాన ప్రోగ్రామ్ నుండి వేరియబుల్స్‌ని సమూహ SQL స్టేట్‌మెంట్‌లలో ఉపయోగించవచ్చు. (ఈ అధ్యాయంలో ఉపయోగించిన SQL గుర్తించబడని పక్షంలో సమూహ SQL గా అర్థం అవుతుంది.) వేరియబుల్ యొక్క ప్రస్తుత విలువ కమాండ్‌లో ఉపయోగించిన విలువ కావచ్చు. ప్రధాన వేరియబుల్స్ ఉండాలి -

* SQL DECLARE సెషన్‌లో ప్రకటించబడుతుంది, ఇది తరువాత వివరించబడుతుంది.

* SQL కమాండ్‌లో వాటి ఫంక్షన్‌లతో అనుకూలమైన డేటా రకాన్ని కలిగి ఉండండి (ఉదాహరణకు, న్యూమరిక్ ఫీల్డ్‌లోకి చేర్చినట్లయితే న్యూమరిక్ టైప్)

* SQL కమాండ్‌లో ఉపయోగించినప్పుడు విలువకు కేటాయించబడుతుంది, ఒకవేళ SQL కమాండ్ కూడా అసైన్‌మెంట్ చేయలేకపోతే.

* SQL ఆదేశంలో పేర్కొన్నప్పుడు పెద్దప్రేగు (:)

మాస్టర్ వేరియబుల్స్ SQL కాలమ్ పేర్ల నుండి ఒక పెద్దప్రేగు కలిగి ఉన్నందున, అవసరమైతే, మీ నిలువు వరుసల పేర్లతో వేరియబుల్స్ ఉపయోగించవచ్చు. మీ ప్రోగ్రామ్‌లో మీకు id_num, సేల్స్‌పర్సన్, లోక్ మరియు కామ్ అనే నాలుగు వేరియబుల్స్ ఉన్నాయని అనుకుందాం. మీరు విక్రేతల పట్టికలో మీరు చొప్పించదలిచిన విలువలను కలిగి ఉంటారు. మీరు మీ ప్రోగ్రామ్‌లో కింది SQL కమాండ్‌ని గూడు కట్టుకోవచ్చు: EXEC SQL ఇన్సర్ట్ ఇన్ సేల్‌స్పీపుల్ వాల్యూస్ (: id_num ,: సేల్స్‌పర్సన్, లొక్ ,: comm) ఈ వేరియబుల్స్ యొక్క ప్రస్తుత విలువలు టేబుల్‌లో ఉంచబడతాయి. మీరు చూడగలిగినట్లుగా, ఈ విలువ గూడులో ఉన్న కాలమ్‌కి సమానమైన అర్థాన్ని comm కలిగి ఉంటుంది. కమాండ్ చివర సెమికోలన్ లేదని గమనించండి. ఎందుకంటే గూడు కట్టుకున్న SQL స్టేట్‌మెంట్‌కి తగిన పూర్తి చేయడం గూడును తయారు చేస్తున్న భాషపై ఆధారపడి ఉంటుంది.

పాస్కల్ మరియు PL / 1 కొరకు, ఇది సెమికోలన్ అవుతుంది; COBOL కోసం, పదం END-EXEC; మరియు FORTRAN కోసం పూర్తి చేయబడదు. ఇతర భాషలలో, ఇది అమలుపై ఆధారపడి ఉంటుంది, కాబట్టి ఇంటరాక్టివ్ SQL మరియు పాస్కల్‌కి విరుద్ధంగా ఉండకుండా అన్ని సమయాల్లో సెమికోలన్‌లను (ఈ పుస్తకంలో) ఉపయోగించడానికి మేము అంగీకరిస్తాము. పాస్కల్ సమూహ SQL మరియు స్థానిక ఆదేశాలను అదే విధంగా ముగించింది - సెమికోలన్‌తో. పైన వివరించిన విధంగా పూర్తిగా కమాండ్ చేయడానికి మార్గం ఏమిటంటే, ఈ క్రింది ఉదాహరణలో చూపిన విధంగా ఒక లూప్‌లో చేర్చడం మరియు విభిన్న వేరియబుల్ విలువలతో పునరావృతం చేయడం , విక్రేత, లోక్, కామ్); విక్రయదారుల విలువలలో EXEC SOL ఇన్సర్ట్ (: id_num ,: విక్రేత ,: loc ,: comm); ముగింపు; PASCAL ప్రోగ్రామ్ యొక్క ఒక భాగం ఒక ఫైల్ నుండి విలువలను చదివి, వాటిని నాలుగు పేరున్న వేరియబుల్స్‌లో నిల్వ చేస్తుంది, ఈ వేరియబుల్స్ విలువలను విక్రేతల పట్టికలో భద్రపరుస్తుంది, ఆపై తదుపరి నాలుగు విలువలను చదివి, ఈ ప్రక్రియను పునరావృతం చేస్తుంది. మొత్తం ఇన్‌పుట్ ఫైల్ చదవబడే వరకు. ప్రతి విలువ సెట్ క్యారేజ్ రిటర్న్‌తో ముగుస్తుందని భావించబడుతుంది (పాస్కల్ గురించి తెలియని వారికి, రీడ్‌ఎల్ ఫంక్షన్ ఇన్‌పుట్ సమాచారాన్ని చదివి, ఈ సమాచారం యొక్క మూలం యొక్క తదుపరి లైన్‌కు వెళుతుంది). ఇది టెక్స్ట్ ఫైల్ నుండి రిలేషనల్ స్ట్రక్చర్‌కు డేటాను పాస్ చేయడానికి సులభమైన మార్గాన్ని అందిస్తుంది. వాస్తవానికి, మీరు మొదట మీ ప్రధాన భాషలో ఏ విధంగానైనా డేటాను ప్రాసెస్ చేయవచ్చు, ఉదాహరణకు విలువ కంటే తక్కువ ఉన్న అన్ని కమీషన్‌లను మినహాయించడానికి. comm); comm> = .12 అయితే అమ్మకందారుల విలువల్లోకి SQL చొప్పించండి ముగింపు; కామ్> = .12 కండిషన్‌కు సరిపోయే లైన్‌లు మాత్రమే అవుట్‌పుట్‌లోకి చేర్చబడతాయి. హోస్ట్ లాంగ్వేజ్ కోసం మీరు లూప్‌లు మరియు షరతులను రెండింటినీ మామూలుగా ఉపయోగించవచ్చని ఇది చూపుతుంది.

వేరియబుల్స్ ప్రకటించడం

SQL స్టేట్‌మెంట్‌లలో ప్రస్తావించబడిన అన్ని వేరియబుల్స్ మొదట సాధారణ హోస్ట్ లాంగ్వేజ్ వాక్యనిర్మాణాన్ని ఉపయోగించి SQL డిక్లరేషన్ విభాగంలో ప్రకటించాలి. మీరు ప్రోగ్రామ్‌లో అలాంటి అనేక విభాగాలను కలిగి ఉండవచ్చు మరియు హోస్ట్ లాంగ్వేజ్ ద్వారా నిర్వచించబడిన పరిమితులకు లోబడి, వేరియబుల్ ఉపయోగించే ముందు వాటిని కోడ్‌లో ఎక్కడైనా ఉంచవచ్చు. డిక్లరేషన్ విభాగం తప్పనిసరిగా తప్పనిసరిగా తప్పనిసరిగా SQL స్టేట్‌మెంట్‌లతో ప్రారంభించాలి మరియు ముగించాలి - EXEC SQL (ఎగ్జిక్యూట్) ద్వారా మునుపటిలాగానే, ప్రారంభ డిక్లార్ సెక్షన్ మరియు ఎండ్ డిక్లార్ సెక్షన్. మునుపటి ఉదాహరణలో ఉపయోగించిన వేరియబుల్స్ ప్రకటించడానికి, మీరు ఈ క్రింది వాటిని నమోదు చేయవచ్చు: EXEC SQL ప్రారంభ డిక్లరేషన్ విభాగం; Var id-num: పూర్ణాంకం; విక్రేత: ప్యాక్డ్ అర్రే (1 .10) ఓట్ చార్; loc: ప్యాక్డ్ అర్రే (1. .10) ot char; comm: నిజమైన; EXEC SQL ముగింపు ముగింపు విభాగం; PASKAL గురించి తెలియని వారికి, Var అనేది ప్రకటించబడిన వేరియబుల్స్ శ్రేణికి ముందు ఉన్న ఒక హెడర్, మరియు ప్యాక్ చేయబడిన (లేదా ప్యాక్ చేయని) శ్రేణులు సంఖ్యల ద్వారా వేరు చేయబడిన స్థిర వేరియబుల్ విలువల శ్రేణి (ఉదాహరణకు, మూడవ స్థాన అక్షరం స్థానంగా ఉంటుంది (3) )) ప్రతి వేరియబుల్ తర్వాత సెమికోలన్ వాడకం ఇది పాస్కల్ మరియు SQL కాదని సూచిస్తుంది.

వేరియబుల్స్ యొక్క విలువలను విశ్లేషించడం

SQL ఆదేశాలను ఉపయోగించి పట్టికలలో వేరియబుల్స్ విలువలను ఉంచడంతో పాటు, ఈ వేరియబుల్స్ కోసం విలువలను పొందడానికి మీరు SQL ని ఉపయోగించవచ్చు. INTO నిబంధనను కలిగి ఉన్న SELECT ఆదేశం యొక్క వైవిధ్యంతో దీన్ని చేయడానికి ఒక మార్గం. మా మునుపటి ఉదాహరణకి వెళ్లి, విక్రేతల పట్టిక నుండి పీల్ వరుసను మా ప్రధాన భాషా వేరియబుల్స్‌లోకి తరలించండి. EXEC SQL సెలక్ట్ స్నామ్, స్నామ్, సిటీ, కామ్ ఇన్‌టో: id_num ,: సేల్స్‌పర్సన్,: లొక్ ,: సేమ్‌స్పీల నుండి కామ్ ఇక్కడ స్నమ్ = 1001; INTO నిబంధనలో పేర్కొన్న ఆర్డర్ చేసిన పేర్లతో ఎంచుకున్న విలువలు వేరియబుల్స్‌లో ఉంచబడతాయి. వాస్తవానికి, INTO నిబంధనలో పేర్కొన్న పేర్లతో ఉన్న వేరియబుల్స్ తప్పనిసరిగా ఈ విలువలను ఆమోదించడానికి తగిన రకాన్ని కలిగి ఉండాలి మరియు ఎంచుకున్న ప్రతి కాలమ్‌కు తప్పనిసరిగా వేరియబుల్ ఉండాలి. మీరు INTO నిబంధన ఉనికిని పరిగణనలోకి తీసుకోకపోతే, ఈ అభ్యర్థన ఏ ఇతర లాగా ఉంటుంది. అయితే, INTO యొక్క ప్రతిపాదన అభ్యర్థనకు గణనీయమైన పరిమితిని జోడిస్తుంది. ప్రశ్న తప్పనిసరిగా ఒక వరుసలో తిరిగి పొందాలి. ఇది అనేక వరుసలను పొందుతుంటే, అవన్నీ ఒకే సమయంలో ఒకే వేరియబుల్‌లోకి చేర్చబడవు. జట్టు సహజంగా విఫలమవుతుంది. ఈ కారణంగా, ఈ క్రింది పరిస్థితులలో మాత్రమే ఎంపిక చేసుకోండి:

* మీరు ఈ ఉదాహరణలో ఉన్నట్లుగా, ప్రత్యేకంగా ఉండే విలువను ధృవీకరించే ఒక ప్రిడికేట్‌ను ఉపయోగించినప్పుడు. 17 వ అధ్యాయంలో చర్చించినట్లుగా, ప్రత్యేకమైన ప్రత్యేకత అడ్డంకి లేదా ప్రత్యేక సూచిక కలిగినవి ప్రత్యేకంగా ఉండవచ్చని మీకు తెలిసిన విలువలు.

* మీరు ఒకటి లేదా అంతకంటే ఎక్కువ మొత్తం ఫంక్షన్‌లను ఉపయోగిస్తున్నప్పుడు మరియు గ్రూప్ ద్వారా ఉపయోగించనప్పుడు.

* మీరు ఒక సింగిల్ పేరెంట్ కీ విలువను ప్రస్తావించే విదేశీ కీపై సెలెక్ట్ డిస్ట్రిక్ట్‌ను ఉపయోగించినప్పుడు (మీ సిస్టమ్ రిఫరెన్స్ సమగ్రతను అమలు చేస్తుంది), కింది ఉదాహరణలో: EXEC SQL డిస్ట్రిక్ట్ స్నమ్ ఇన్‌టూ: కస్టమర్‌ల నుండి సేల్స్‌నమ్ ఇక్కడ నుండి = (ముక్కును ఎంచుకోండి విక్రేతల నుండి పేరు ఎక్కడ "= మోతిక"); Salespeople.sname మరియు Salespeople.snum వరుసగా ఈ పట్టిక యొక్క ప్రత్యేకమైన మరియు ప్రాధమిక కీలు అని భావించబడింది, మరియు Customers.snum అనేది Salespeople.snum ని సూచిస్తున్న విదేశీ కీ, మరియు ఈ ప్రశ్న ఒకే వరుసను ఉత్పత్తి చేస్తుందని మీరు ఊహించారు. ఒక ప్రశ్న ఒకే లైన్ అవుట్‌పుట్‌ను ఉత్పత్తి చేస్తుందని మీకు తెలిసిన ఇతర సందర్భాలు కూడా ఉన్నాయి, కానీ అవి పెద్దగా తెలియవు మరియు చాలా సందర్భాలలో, మీ డేటా పరిమితుల ద్వారా అమలు చేయలేని సమగ్రతను కలిగి ఉంటుంది. దీనిపై ఆధారపడవద్దు! మీరు కొంతకాలం ఉపయోగించబడే ఒక ప్రోగ్రామ్‌ని సృష్టిస్తున్నారు మరియు భవిష్యత్తులో వైఫల్యాలకు హామీ ఇవ్వడానికి దాన్ని ప్లే చేయడం ఉత్తమం. ఏదేమైనా, ఒకే వరుసలను ఉత్పత్తి చేసే ప్రశ్నలను సమూహపరచాల్సిన అవసరం లేదు, ఎందుకంటే SELECT INTO సౌలభ్యం కోసం మాత్రమే ఉపయోగించబడుతుంది. మీరు చూస్తున్నట్లుగా, కర్సర్‌ని ఉపయోగించి బహుళ పంక్తులను ముద్రించడానికి మీరు ప్రశ్నలను ఉపయోగించవచ్చు.

కర్సర్

SQL యొక్క బలాలలో ఒకటి, ఎన్ని వరుసలు ఉండవచ్చో తెలియకుండానే బ్లాక్ రికార్డ్‌గా నిర్దిష్ట పరిస్థితిని తీర్చడానికి టేబుల్‌లోని అన్ని వరుసలలో పనిచేసే సామర్ధ్యం. పది పంక్తులు అంచనాను సంతృప్తిపరిస్తే, అప్పుడు ప్రశ్న అన్ని పది లైన్లను అవుట్పుట్ చేయగలదు. పది మిలియన్ లైన్లు పేర్కొనబడితే, మొత్తం పది మిలియన్ లైన్లు అవుట్‌పుట్ అవుతాయి. మీరు ఇతర భాషలతో లింక్ చేయడానికి ప్రయత్నించినప్పుడు ఇది కొంచెం కష్టం. అవుట్‌పుట్ ఎంత పెద్దదిగా ఉంటుందో మీకు తెలియనప్పుడు మీరు వేరియబుల్స్‌కు ప్రశ్న అవుట్‌పుట్‌ను ఎలా కేటాయించవచ్చు? కర్సర్ అని పిలవబడే దాన్ని ఉపయోగించడం పరిష్కారం. కంప్యూటర్ స్క్రీన్‌లో మీ స్థానాన్ని గుర్తించే రెప్పపాటు డాష్‌గా మీరు బహుశా కర్సర్‌తో సుపరిచితులు కావచ్చు. అనలాగ్‌లు పూర్తి కానప్పటికీ, ప్రశ్న అవుట్‌పుట్‌లో మీ స్థానాన్ని గుర్తించే పరికరంగా మీరు SQL కర్సర్‌ని ఆలోచించవచ్చు. కర్సర్ అనేది అభ్యర్థనతో అనుబంధించబడిన ఒక రకమైన వేరియబుల్. ఈ వేరియబుల్ విలువ అభ్యర్థనపై ప్రదర్శించబడే ప్రతి పంక్తి కావచ్చు. ప్రధాన వేరియబుల్స్ లాగా, కర్సర్‌లను ఉపయోగించడానికి ముందు తప్పనిసరిగా ప్రకటించాలి. ఇది ఈ క్రింది విధంగా DECLARE CURSOR ఆదేశంతో చేయబడుతుంది: EXEC SQL DECLARE CURSOR లండన్‌సేల్స్ ఎంపిక కోసం * నగరం నుండి విక్రయదారుల నుండి = "లండన్"; అభ్యర్థన వెంటనే అమలు చేయబడదు; అతను మాత్రమే నిశ్చయించుకున్నాడు. కర్సర్ ఒక దృశ్యం లాంటిది, దీనిలో కర్సర్ ఒక ప్రశ్నను కలిగి ఉంటుంది మరియు కర్సర్‌లోని ప్రతి విషయం కర్సర్ తెరిచిన ప్రతిసారీ ఏదైనా ప్రశ్న అవుట్‌పుట్‌ను పోలి ఉంటుంది. అయితే, బేస్ టేబుల్స్ లేదా వీక్షణలు కాకుండా, కర్సర్ అడ్డు వరుసలు ఆర్డర్ చేయబడ్డాయి: మొదటి, రెండవ ... ... మరియు చివరి కర్సర్ వరుస ఉంది. ఈ ఆర్డరింగ్ ఏకపక్షంగా ఉండవచ్చు, ప్రశ్నలోని ఆర్డర్ బై క్లాజ్ ద్వారా స్పష్టంగా నియంత్రించబడుతుంది లేదా ఇన్స్ట్రుమెంట్-నిర్వచించిన స్కీమా ద్వారా నిర్వచించబడిన కొన్ని ఆర్డర్‌లకు డిఫాల్ట్ కావచ్చు. మీ ప్రోగ్రామ్‌లో మీరు ఒక ప్రశ్నను అమలు చేయాలనుకున్నప్పుడు, మీరు కింది ఆదేశంతో కర్సర్‌ని తెరవండి: EXEC SQL ఓపెన్ కర్సర్ లండన్‌సేల్స్; మీరు ఈ ప్రత్యేక ఆదేశాన్ని అమలు చేసినప్పుడు కర్సర్‌లోని విలువలను పొందవచ్చు, కానీ మునుపటి DECLARE ఆదేశం కాదు మరియు తదుపరి FETCH ఆదేశం కాదు. అప్పుడు, మీరు ఈ అభ్యర్థన నుండి అవుట్‌పుట్‌ను పొందడానికి FETCH ఆదేశాన్ని ఉపయోగించండి, ఒక సమయంలో ఒక లైన్. EXEC SQL FETCH లండన్సేల్స్ INTO: id_num ,: అమ్మకందారుడు,: loc ,: comm; ఈ వ్యక్తీకరణ మొదటి ఎంచుకున్న అడ్డు వరుస నుండి వేరియబుల్స్‌కు విలువలను తరలిస్తుంది. మరొక FETCH ఆదేశం కింది విలువలను సెట్ చేస్తుంది. లూప్ లోపల FETCH కమాండ్‌ను ఉంచాలనే ఆలోచన ఉంది, తద్వారా మీరు ఒక వరుసను ఎంచుకున్న తర్వాత, ఆ వరుస నుండి వేరియబుల్స్‌కు విలువల సమితిని తరలించవచ్చు, ఆపై తదుపరి విలువలను తరలించడానికి లూప్‌లోకి తిరిగి లూప్ చేయండి అదే వేరియబుల్స్‌లోకి. ఉదాహరణకు, అవుట్‌పుట్ ఒకేసారి ఒక లైన్ ప్రదర్శించబడాలని మీరు కోరుకుంటారు, ప్రతిసారి వినియోగదారుడు తదుపరి పంక్తిని చూడాలనుకుంటున్నారా అని అడుగుతూ Look_at_more: = నిజం; EXEC SQL ఓపెన్ కర్సర్ లండన్సేల్స్; లుక్_అట్_ఇంకా EXEC SQL FETCH లండన్‌సేల్స్ ప్రారంభమవుతుంది: id_num ,: విక్రేత ,: loc ,: comm; రైటెల్న్ (id_num, విక్రేత, లోక్, కామ్); Writeln ("మీరు మరింత డేటాను చూడాలనుకుంటున్నారా? (Y / N)"); readln (ప్రతిస్పందన); దాని ప్రతిస్పందన = "N" అప్పుడు Look_at_more: = తప్పుడు ముగింపు; EXEC SQL క్లోజ్ కర్సర్ లండన్సేల్స్; పాస్కల్‌లో, సంకేతం: = అంటే - "కేటాయించిన విలువ", అయితే = ఇప్పటికీ "సమానం" అనే సాధారణ అర్థాన్ని కలిగి ఉంది. రైటెల్ తన అవుట్‌పుట్‌ను వ్రాసి, ఆపై కొత్త పంక్తికి వెళ్తాడు. రెండవ రైటెల్‌లో అక్షర విలువల చుట్టూ ఒకే కోట్‌లు మరియు ఒకవేళ ... పాస్‌కల్‌లో క్లాజు సాధారణం, ఇది SQL లో నకిలీలతో జరుగుతుంది. ఈ స్నిప్పెట్ ఫలితంగా, లుక్_అట్ _ అనే పేరు గల బూలియన్ వేరియబుల్ తప్పనిసరిగా ఒప్పుకు సెట్ చేయబడాలి, కర్సర్ తెరిచి, లూప్ ఎంటర్ చేయాలి. లూప్ లోపల, కర్సర్ నుండి ఒక లైన్ తీసి ప్రదర్శించబడుతుంది. అతను తదుపరి పంక్తిని చూడాలనుకుంటున్నారా అని వినియోగదారుని అడుగుతారు. అతను N (నో) చెప్పే వరకు, లూప్ పునరావృతమవుతుంది మరియు తదుపరి వరుస విలువలు ఎంపిక చేయబడతాయి. లుక్_అట్_మోర్ మరియు రెస్పాన్స్ వేరియబుల్స్ తప్పనిసరిగా బూలియన్ మరియు చార్ అని ప్రకటించాల్సి ఉన్నప్పటికీ, పాస్కల్‌లోని వేరియబుల్ డిక్లరేషన్ విభాగంలో, అవి SQL కమాండ్‌లలో ఉపయోగించబడనందున వాటిని SQL డిక్లరేషన్ విభాగంలో చేర్చకూడదు. మీరు గమనిస్తే, వేరియబుల్ పేర్ల ముందు ఉన్న కోలన్‌లు SQL కాని స్టేట్‌మెంట్‌లకు ఉపయోగించబడవు. తరువాత, ఓపెన్ కర్సర్ స్టేట్‌మెంట్‌కు సంబంధించిన క్లోజ్ కర్సర్ స్టేట్‌మెంట్ ఉందని గమనించండి. ఇది, మీరు అర్థం చేసుకున్నట్లుగా, విలువల కర్సర్‌ని విముక్తి చేస్తుంది, కాబట్టి తదుపరి విలువల ఎంపికకు వెళ్లడానికి ముందు ప్రశ్నను ఓపెన్ కర్సర్ స్టేట్‌మెంట్‌తో పునరావృతం చేయాలి. కర్సర్ మూసివేయబడిన తర్వాత ప్రశ్న ద్వారా ఎంపిక చేయబడిన అడ్డు వరుసలకు ఇది అవసరం లేదు, అయితే ఇది సాధారణ ప్రక్రియ. కర్సర్ మూసివేయబడినప్పుడు, ఏ వరుసలు ఎంపిక చేయబడ్డాయో SQL ట్రాక్ చేయదు. మీరు కర్సర్‌ను మళ్లీ తెరిస్తే, ఆ పాయింట్ నుండి ప్రశ్న తిరిగి అమలు చేయబడుతుంది మరియు మీరు మళ్లీ ప్రారంభించండి. అన్ని వరుసలు ఇప్పటికే ఎంచుకోబడినప్పుడు ఈ ఉదాహరణ స్వయంచాలకంగా లూప్ నుండి నిష్క్రమించదు. FETCH తిరిగి పొందడానికి వరుసలు లేనప్పుడు, అది INTO నిబంధన వేరియబుల్స్‌లోని విలువలను మార్చదు. అందువల్ల, డేటా అయిపోయినట్లయితే, వినియోగదారు సమాధానాన్ని నమోదు చేయడం ద్వారా లూప్‌ను ముగించే వరకు ఈ వేరియబుల్స్ ఒకే విలువలతో పదేపదే అవుట్‌పుట్ అవుతాయి - ఎన్.

SQL కోడ్‌లు

డేటా ఎప్పుడు అయిపోతుందో తెలుసుకోవడం మంచిది, తద్వారా మీరు దీని గురించి వినియోగదారుకు తెలియజేయవచ్చు మరియు చక్రం స్వయంచాలకంగా ముగుస్తుంది. ఉదాహరణకు, SQL ఆదేశం లోపంతో అమలు చేయబడిందని తెలుసుకోవడం కంటే ఇది చాలా ముఖ్యం. వేరియబుల్ SQLCODE (ఫోర్ట్రాన్‌లో SQLCOD అని కూడా పిలుస్తారు) ఈ కార్యాచరణను అందించడానికి ఉద్దేశించబడింది. ఇది తప్పనిసరిగా హోస్ట్ లాంగ్వేజ్ వేరియబుల్‌గా నిర్వచించబడాలి మరియు అనుబంధం B లో చూపిన విధంగా హోస్ట్ లాంగ్వేజ్‌లోని ఖచ్చితమైన సంఖ్యా SQL రకాల్లో ఒకదానితో సరిపోయే డేటా రకం అయి ఉండాలి. SQL ఆదేశం అమలు చేయబడిన ప్రతిసారీ SQLCODE సెట్ చేయబడుతుంది. ప్రాథమికంగా, మూడు అవకాశాలు ఉన్నాయి: 1. కమాండ్ లోపం లేకుండా నడిచింది, కానీ ఎటువంటి చర్య తీసుకోలేదు. వివిధ జట్లకు ఇది భిన్నంగా కనిపిస్తుంది:

A) ఎంపిక కోసం, ప్రశ్న ద్వారా ఏ వరుసను ఎంచుకోలేదు.

B) FETCH కోసం, చివరి వరుస ఇప్పటికే ఎంపిక చేయబడింది, లేదా కర్సర్‌లోని ప్రశ్న ద్వారా అడ్డు వరుస ఎంపిక చేయబడలేదు.

సి) ఇన్సర్ట్ కోసం, అడ్డు వరుసలు ఏవీ చొప్పించబడలేదు (చొప్పించడం కోసం విలువలను రూపొందించడానికి ప్రశ్న ఉపయోగించబడిందని భావించండి మరియు ఏదైనా అడ్డు వరుసను పొందడానికి ప్రయత్నించినప్పుడు తిరస్కరించబడింది.

డి) అప్‌డేట్ మరియు డిలీట్ కోసం, ఏ రో కూడా ప్రిడికేట్ కండిషన్‌ను అందుకోలేదు, అందుచేత టేబుల్‌లో ఎలాంటి మార్పులు చేయబడవు.

ఏదైనా సందర్భంలో, SQLCODE = 100 సెట్ చేయబడుతుంది.

2. కమాండ్ పైన పేర్కొన్న షరతులలో ఏదీ నెరవేర్చకుండా సాధారణంగా నడుస్తుంది. ఈ సందర్భంలో, SQLCOD = 0 సెట్ చేయబడుతుంది.

3. కమాండ్ లోపం సృష్టించింది. ఇది జరిగితే, ప్రస్తుత లావాదేవీ ద్వారా డేటాబేస్‌లో చేసిన మార్పులు తిరిగి ఇవ్వబడతాయి (చాప్టర్ 23 చూడండి). ఈ సందర్భంలో, SQLCODE కోడ్ సెట్ చేయబడుతుంది = డిజైనర్ నిర్ణయించిన కొన్ని ప్రతికూల సంఖ్య. ఈ నంబర్ యొక్క పని సాధ్యమైనంత ఖచ్చితంగా సమస్యను గుర్తించడం. ప్రాథమికంగా, మీ సిస్టమ్ తప్పనిసరిగా సబ్‌రౌటిన్‌తో సరఫరా చేయబడాలి, ఈ సందర్భంలో మీ డిజైనర్ ద్వారా నిర్ణయించబడిన నెగటివ్ నంబర్ విలువను డీక్రిప్ట్ చేసే సమాచారాన్ని మీకు అందించాలి. ఈ సందర్భంలో, కొంత లోపం సందేశం తెరపై ప్రదర్శించబడుతుంది లేదా లాగ్ ఫైల్‌కు వ్రాయబడుతుంది, అయితే ప్రోగ్రామ్ ప్రస్తుత లావాదేవీకి సంబంధించిన మార్పులను పునరుద్ధరిస్తుంది, డేటాబేస్ నుండి డిస్‌కనెక్ట్ చేసి దాని నుండి నిష్క్రమించండి. ఇప్పుడు మనం మెరుగుపరచవచ్చు

సైక్లెస్‌ని నియంత్రించడానికి స్క్లకోడ్‌ని ఉపయోగించడం

స్వయంచాలకంగా లూప్ నుండి నిష్క్రమించడానికి మా మునుపటి ఉదాహరణ, కర్సర్ ఖాళీగా ఉన్నట్లయితే, అన్ని అడ్డు వరుసలు ఎంపిక చేయబడ్డాయి లేదా లోపం సంభవించింది: Look_at_more: = lhe; EXEC SQL ఓపెన్ కర్సర్ లండన్సేల్స్; Look_at_more మరియు SQLCODE = O ప్రారంభించండి EXEC SQL FETCH లండన్ $ ales INTO: id_num ,: విక్రేత ,: loc ,: comm; రైటెల్న్ (id_num, విక్రేత, లోక్, కామ్); Writeln ("మీరు మరింత డేటాను చూడాలనుకుంటున్నారా? (Y / N)"); readln (ప్రతిస్పందన); ప్రతిస్పందన = "N" అయితే అప్పుడు Look_at_more: = Fabe; ముగింపు; EXEC SQL క్లోజ్ కర్సర్ లండన్సేల్స్;

ఎప్పుడు ఆఫర్

షరతు నెరవేరినప్పుడు నిష్క్రమించడానికి ఇది సౌకర్యవంతంగా ఉంటుంది - అన్ని అడ్డు వరుసలు ఎంపిక చేయబడ్డాయి. కానీ మీకు లోపం వస్తే, పైన పేర్కొన్న మూడవ కేసు కోసం వివరించిన విధంగా మీరు ఏదో ఒకటి చేయాలి. ఈ ప్రయోజనం కోసం, SQL ఒక GOTO నిబంధనను అందిస్తుంది. వాస్తవానికి, ఒక నిర్దిష్ట SQLCODE ఉత్పత్తి చేయబడితే ఒక ప్రోగ్రామ్ స్వయంచాలకంగా GOTO ఆదేశాన్ని అమలు చేయగలంత విస్తృతంగా వర్తింపజేయడానికి SQL మిమ్మల్ని అనుమతిస్తుంది. మీరు దీన్ని ఎక్కడ క్లాజ్‌తో కలిపి చేయవచ్చు. ఈ కేస్ కోసం ఒక నమూనా స్నిప్పెట్ ఉంది: EXEC SQL ఉన్నప్పుడు స్క్లరర్ GOTO Error_handler; EXEC SQL కొనసాగింపును ఎప్పుడు కనుగొనలేదు; SQLEROD అనేది SQLCODE అని చెప్పడానికి మరొక మార్గం< 0; а NOT FOUND - это другой способ сообщить что SQLCODE = 100. (Некоторые реализации называют последний случай еще как - SQLWARNING.) Error_handler - это им того места в программе в которое будет пере- несено выполнение программы если произошла ошибка (GOTO может состоять из одного или двух слов). Такое место определяется любым способом соответствующим для главного языка, например, с помощью метки в Паскале, или имени раздела или имени параграфа в КОБОЛЕ (в дальнейшем мы будем использовать термин - метка). Метка более удач- но идентифицирует стандартную процедуру распространяемую проектировщиком для включения во все программы.

SQLCODE విలువ కోసం CONTINUE ప్రత్యేకంగా ఏమీ చేయదు. ఇది డిఫాల్ట్ కూడా. మీరు SQLCODE విలువను పేర్కొనే WHENEVER ఆదేశాన్ని ఉపయోగించకపోతే. ఏదేమైనా, ఈ క్రియారహిత నిర్వచనాలు మీ ప్రోగ్రామ్‌లోని వివిధ పాయింట్ల (లేబుల్‌లు) వద్ద చర్యలను నిర్వహించకుండా మరియు ముందుకు వెనుకకు మారే సామర్థ్యాన్ని మీకు అందిస్తాయి. ఉదాహరణకు, మీ ప్రోగ్రామ్ విలువలను ఉత్పత్తి చేయాల్సిన ప్రశ్నలను ఉపయోగించే బహుళ ఇన్సర్ట్ స్టేట్‌మెంట్‌లను కలిగి ఉంటే, మీరు ప్రత్యేక సందేశాన్ని ముద్రించవచ్చు లేదా ప్రశ్నలు ఖాళీగా తిరిగి వస్తాయి మరియు విలువలు ఏవీ చేర్చబడలేదని స్పష్టం చేయడానికి ఏదైనా చేయవచ్చు. ... ఈ సందర్భంలో, మీరు ఈ క్రింది వాటిని నమోదు చేయవచ్చు: EXEC SQL ఎప్పుడు GOTO No_rows ను కనుగొనలేదు; No_rows అనేది ఒక నిర్దిష్ట చర్యను కలిగి ఉన్న కొన్ని కోడ్‌లోని లేబుల్. మరోవైపు, మీరు ప్రోగ్రామ్‌లో తర్వాత ఎంపిక చేయాల్సి వస్తే, ఈ సమయంలో మీరు కింది వాటిని నమోదు చేయవచ్చు, కొనసాగకుండా ఉన్నప్పుడు EXEC SQL. కాబట్టి అన్ని వరుసలు తెచ్చే వరకు ఎంపిక పునరావృతమవుతుంది, ఇది ప్రత్యేక ప్రాసెసింగ్ అవసరం లేని సాధారణ ప్రక్రియ.

కర్సర్‌లను సవరించడం

పట్టిక నుండి వరుసల సమూహాన్ని ఎంచుకోవడానికి కర్సర్‌లను కూడా ఉపయోగించవచ్చు, తర్వాత వాటిని ఒక్కొక్కటిగా సవరించవచ్చు లేదా తొలగించవచ్చు. ఇది అప్‌డేట్ మరియు డిలీట్ కమాండ్‌లలో ఉపయోగించే అంచనాల పరిమితుల చుట్టూ పని చేసే సామర్థ్యాన్ని మీకు అందిస్తుంది. మీరు కర్సర్ క్వెరీ ప్రిడికేట్‌లో పాల్గొన్న పట్టికను లేదా ఆ ఆదేశాల అంచనాలో మీరు అమలు చేయలేని దాని సబ్‌క్వరీలను చూడవచ్చు. చాప్టర్ 16 లో హైలైట్ చేయబడినట్లుగా, కింది రేటింగ్‌లో సగటు కంటే తక్కువ రేటింగ్ ఉన్న వినియోగదారులందరినీ తొలగించే ప్రయత్నాన్ని SQL స్టాండర్డ్ తిరస్కరించింది: EXEC SQL డిలీట్ కస్టమర్ల నుండి ఇక్కడ రేటింగ్< (SELECT AVG (rating) FROM Customers); Однако, вы можете получить тот же эффект, используя запрос для выбора соответствующих строк, запомнив их в курсоре, и выполнив DELETE с использованием курсора. Сначала вы должны объявить курсор: EXEC SQL DECLARE Belowavg CURSOR FOR SELECT * FROM Customers WHERE rating < (SELECT AVG (rating) FROM Customers); Затем вы должны создать цикл, чтобы удалить всех заказчиков выбранных курсором: EXEC SQL WHENEVER SQLERROR GOTO Error_handler; EXEC SQL OPEN CURSOR Belowavg; while not SOLCODE = 100 do begin EXEC SOL FETCH Belowavg INTO:a, :b, :c, :d, :e; EXEC SOL DELETE FROM Customers WHERE CURRENT OF Belowavg; end; EXEC SOL CLOSE CURSOR Belowavg; Предложение WHERE CURRENT OF означает что DELETE применяется к строке которая в настоящее время выбрана курсором. Здесь подразумевается, что и курсор и команда DELETE, ссылаются на одну и ту же таблицу, и следовательно, что запрос в курсоре - это не объединение. Курсор должен также быть модифицируемым. Являясь модифицируемым, курсор должен удовлетворять тем же условиям что и представления (см. Главу 21). Кроме того, ORDER BY и UNION, которые не разрешены в представлениях, в курсорах - разрешаются, но предохраняют курсор от модифицируемости. Обратите внимание в вышеупомянутом примере, что мы должны выбирать строки из курсора в набор переменных, даже если мы не собирались использовать эти переменные. Этого требует синтаксис команды FETCH. UPDATE работает так же. Вы можете увеличить значение комиссионных всем продавцам, которые имеют заказчиков с оценкой=300, следующим способом. Сначала вы объявляете курсор: EXEC SOL DECLARE CURSOR High_Cust AS SELECT * FROM Salespeople WHERE snum IN (SELECT snum FROM Customers WHERE rating = 300); Затем вы выполняете модификации в цикле: EXEC SQL OPEN CURSOR High_cust; while SQLCODE = 0 do begin EXEC SOL FETCH High_cust INTO:id_num, :salesperson, :loc, :comm; EXEC SQL UPDATE Salespeople SET comm = comm + .01 WHERE CURRENT OF High_cust; end; EXEC SQL CLOSE CURSOR High_cust; Обратите внимание: что некоторые реализации требуют, чтобы вы указы- вали в определении курсора, что курсор будет использоваться для выполнения команды UPDATE на определенных столбцах. Это делается с помощью заключительной фразы определения курсора - FOR UPDATE . Чтобы объявить курсор High_cust таким способом, так чтобы вы мог- ли модифицировать командой UPDATE столбец comm, вы должны ввести следующее предложение: EXEC SQL DECLARE CURSOR High_Cust AS SELECT * FROM Salespeople WHERE snum IN (SELECT snum FROM Customers WHERE rating = 300) FOR UPDATE OF comm; Это обеспечит вас определенной защитой от случайных модификаций, которые могут разрушить весь порядок в базе данных.

వివిధ సూచిక

NULLS విలువలు SQL ద్వారా నిర్వచించబడిన ప్రత్యేక టోకెన్లు. అవి ప్రధాన వేరియబుల్స్‌కి సరిపోవు. ప్రధాన భాషలు నిర్వచనం ప్రకారం SQL లో NULL విలువలకు మద్దతు ఇవ్వనందున, మాస్టర్ వేరియబుల్‌లో NULL విలువలను చొప్పించడానికి ప్రయత్నించడం తప్పు. ప్రధాన వేరియబుల్‌లోకి శూన్య విలువను చొప్పించే ప్రయత్నం యొక్క ఫలితం డిజైనర్ ద్వారా నిర్ణయించబడినప్పటికీ, ఈ ఫలితం డేటాబేస్ సిద్ధాంతానికి విరుద్ధంగా ఉండకూడదు, అందుచేత లోపం ఏర్పడాలి: SQLCODE కోడ్ ప్రతికూల సంఖ్య రూపంలో, మరియు దోష నియంత్రణ దినచర్యకు కాల్ చేయండి. సహజంగా, మీరు దీనిని నివారించాలి. అందువల్ల, మీ ప్రోగ్రామ్‌ని పాడుచేయని చెల్లుబాటు అయ్యే విలువలతో మీరు పూర్తి విలువలను ఎంచుకోవచ్చు. ప్రోగ్రామ్ క్రాష్ అవ్వకపోయినా, ప్రధాన వేరియబుల్స్‌లోని విలువలు చెల్లవు, ఎందుకంటే అవి పూర్తి విలువలను కలిగి ఉండవు. ఈ పరిస్థితికి అందించిన ప్రత్యామ్నాయ పద్ధతి సూచిక వేరియబుల్ ఫంక్షన్. వేరియబుల్ ఇండికేటర్ - SQL డిక్లరేషన్ విభాగంలో ప్రకటించబడింది ఇతర వేరియబుల్స్‌ని పోలి ఉంటుంది. ఇది SQL లోని సంఖ్యా రకానికి సరిపోయే హోస్ట్ లాంగ్వేజ్ రకం కావచ్చు. మీరు హోస్ట్ లాంగ్వేజ్ వేరియబుల్‌లో పూర్తి విలువను ఉంచాల్సిన ఆపరేషన్ చేసినప్పుడు, మీరు విశ్వసనీయత కోసం సూచిక వేరియబుల్‌ను ఉపయోగించాలి. మీరు రక్షించదలిచిన హోస్ట్ లాంగ్వేజ్ వేరియబుల్ తర్వాత వెంటనే మీరు SQL కమాండ్‌లో ఇండికేటర్ వేరియబుల్‌ను ఉంచండి, ఖాళీలు లేదా కామాలు లేకుండా, మీరు ఐచ్ఛికంగా పదాన్ని చేర్చవచ్చు - INDICATOR. కమాండ్‌లోని వేరియబుల్ ఇండికేటర్‌కు మొదట్లో విలువ 0. కేటాయించబడుతుంది, అయితే, ఒక NULL విలువ ఉత్పత్తి చేయబడితే, వేరియబుల్ ఇండికేటర్ నెగటివ్ నంబర్ అవుతుంది. NULL విలువ కనుగొనబడిందో లేదో తెలుసుకోవడానికి మీరు వేరియబుల్ ఇండికేటర్ విలువను తనిఖీ చేయవచ్చు. సెక్స్ సిటీ మరియు కామ్, విక్రేతల పట్టిక పూర్తిగా నిరోధించబడలేదని మరియు SQL డిక్లరేషన్ విభాగంలో, రెండు PASCALIAN పూర్ణాంక వేరియబుల్స్, i_a మరియు i_b లో ప్రకటించామని అనుకుందాం. (డిక్లరేషన్ విభాగంలో వాటిని సూచిక వేరియబుల్స్‌గా సూచించేది ఏదీ లేదు. సూచిక వేరియబుల్స్‌గా ఉపయోగించినప్పుడు అవి సూచిక వేరియబుల్స్‌గా మారతాయి.) ఒక అవకాశం ఉంది: EXEC SQL ఓపెన్ కర్సర్ హై_కస్ట్; అయితే SQLCODE = O ప్రారంభించండి EXEC SQL FETCH High_cust INTO: id_num ,: విక్రేత ,: loc: i_a ,: commINDlCATOR: i_b; I_a> = O మరియు i_b> = O అయితే (NULL లు ఉత్పత్తి చేయబడలేదు) EXEC SQL అప్‌డేట్ విక్రేతలు SET comm = comm + .01 Hlgh_cust యొక్క ప్రస్తుత ప్రదేశం; లేకపోతే (ఒకటి లేదా రెండు శూన్యాలు) i_a అయితే ప్రారంభమవుతుంది< O then writeln ("salesperson ", id_num, " has no city"); If i_b < O then writeln ("salesperson ", id_num, " has no commission"); end; {else} end; {while} EXEC SQL CLOSE CURSOR High_cust; Как вы видите, мы включили, ключевое слово INDICATOR в одном случае, и исключили его в другом случае, чтобы показать, что эффект будет одинаковым в любом случае. Каждая строка будет выбрана, но команда UPDATE выполнится только если NULL значения не будут обнаружены. Если будут обнаружены NULL значения, выполнится еще одна часть программы, которая распечатает предупреждающее сообщение, где было найдено каждое NULL значение. Обратите внимание: переменные indicator должны проверяться в главном языке, как указывалось выше, а не в предложении WHERE команды SQL. Последнее в принципе не запрещено, но результат часто бывает непредвиденным.

మొత్తం SQL విలువలను అనుసరించడానికి సూచిక వేరియబుల్‌ని ఉపయోగించడం

ఇంకొక అవకాశం ఏమిటంటే, సూచిక వేరియబుల్‌ని ప్రతి హోస్ట్ లాంగ్వేజ్ వేరియబుల్‌కి ప్రత్యేక పద్ధతిలో బంధించడం ద్వారా హ్యాండిల్ చేయడం అనేది పూర్తి SQL విలువల ప్రవర్తనను అనుకరిస్తుంది. మీరు మీ ప్రోగ్రామ్‌లో ఈ విలువలలో ఒకదాన్ని ఉపయోగించినప్పుడు, ఉదాహరణకు ఒకవేళ ... తర్వాత క్లాజులో, దాని విలువ శూన్యంగా ఉందో లేదో తెలుసుకోవడానికి మీరు ముందుగా అనుబంధ సూచిక వేరియబుల్‌ని తనిఖీ చేయవచ్చు. అలా అయితే, మీరు వేరియబుల్‌కి భిన్నంగా వ్యవహరిస్తున్నారు. ఉదాహరణకు, ఇండికేటర్ - i_city వేరియబుల్‌తో అనుబంధించబడిన మెయిన్ సిటీ వేరియబుల్ కోసం సిటీ ఫ్లోర్ నుండి NULL విలువ సేకరించబడితే, మీరు తప్పనిసరిగా సిటీ విలువను స్పేస్‌ల సీక్వెన్స్‌కి సెట్ చేయాలి. మీరు దీనిని ప్రింటర్‌లో ప్రింట్ చేయబోతున్నట్లయితే మాత్రమే ఇది అవసరం అవుతుంది; దాని అర్థం మీ ప్రోగ్రామ్ లాజిక్ నుండి భిన్నంగా ఉండకూడదు. సహజంగానే, i_city స్వయంచాలకంగా ప్రతికూల విలువకు సెట్ చేయబడుతుంది. మీ ప్రోగ్రామ్‌లో మీరు ఈ క్రింది నిర్మాణాన్ని కలిగి ఉన్నారని అనుకుందాం: సిటీ = "లండన్" అయితే com: = comm + .01 else comm: = comm - .01 వేరియబుల్ సిటీలోకి ప్రవేశించిన ఏదైనా విలువ "లండన్" కు సమానం లేదా సమానం కాదు . అందువల్ల, ప్రతి సందర్భంలో, కమిషన్ విలువ పెరుగుతుంది లేదా తగ్గుతుంది. అయితే, SQL లో సమానమైన ఆదేశాలు విభిన్నంగా అమలు చేయబడతాయి: EXEC SQL అప్‌డేట్ విక్రేతలు SET comm = comm + .01 ఎక్కడ సిటీ = "లండన్"; మరియు EXEC SQL అప్‌డేట్ విక్రేతలు SET comm = comm .01; ఎక్కడ సిటీ< >"లండన్"; (PASKAL వేరియంట్ ఒకే విలువపై మాత్రమే పనిచేస్తుంది, SQL వేరియంట్ అన్ని పట్టికలలో పనిచేస్తుంది.) SQL వేరియంట్‌లో నగరం శూన్యంగా ఉంటే, రెండు అంచనాలు తెలియవు మరియు కామ్ ఏ విధంగానూ మార్చబడదు. NULL విలువలను మినహాయించే షరతును సృష్టించడం ద్వారా మీ హోస్ట్ లాంగ్వేజ్ స్థిరంగా ప్రవర్తించేలా చేయడానికి మీరు ఇండికేటర్ వేరియబుల్‌ని ఉపయోగించవచ్చు: i_city> = O అప్పుడు మొదలుపెడితే నగరం = "లండన్" అయితే com: = comm + .01 వేరే comm: = comm -. 01; ముగింపు; (ప్రారంభం మరియు ముగింపు ఇక్కడ అర్థం చేసుకోవడానికి మాత్రమే అవసరం)

గమనిక: ఈ ఉదాహరణలోని చివరి పంక్తి ఒక వ్యాఖ్యను కలిగి ఉంది - (ప్రారంభం మరియు ముగింపు అవగాహన ప్రయోజనాల కోసం మాత్రమే)

మరింత క్లిష్టమైన ప్రోగ్రామ్‌లలో, నగరం = NULL అని సూచించడానికి మీరు బూలియన్‌ను ట్రూగా సెట్ చేయాలనుకోవచ్చు. మీకు అవసరమైనప్పుడు మీరు ఆ వేరియబుల్‌ను తనిఖీ చేయవచ్చు.

ఇండికేటర్ వేరియబుల్ యొక్క ఇతర ఉపయోగాలు

వేరియబుల్ ఇండికేటర్‌ను NULL విలువను కేటాయించడానికి కూడా ఉపయోగించవచ్చు. SELECT కమాండ్‌లో ఉన్న విధంగా UPDATE లేదా INSERT కమాండ్‌లోని ప్రధాన వేరియబుల్ పేరుకు జోడించండి. వేరియబుల్ ఇండికేటర్ ప్రతికూలంగా ఉంటే, ఫీల్డ్‌లో NULL విలువ ఉంచబడుతుంది. ఉదాహరణకు, సూచిక వేరియబుల్స్ i_a లేదా i_b ప్రతికూలంగా ఉన్నప్పుడు, కింది ఆదేశం విక్రేత పట్టికలో నగరం మరియు కామ్ ఫ్లోర్‌లో పూర్తి విలువలను ఉంచుతుంది; లేకపోతే, అది ప్రధాన వేరియబుల్స్ విలువలను అక్కడ ఉంచుతుంది: EXEC SQL ఇన్సర్ట్ ఇన్ సేల్‌స్పీపుల్ వాల్యూస్ (: Id_num ,: సేల్స్‌పర్సన్,: లొక్: i_a ,: comm: i_b); వేరియబుల్ సూచిక విస్మరించాల్సిన స్ట్రింగ్‌ను సూచించడానికి కూడా ఉపయోగించబడుతుంది. మీరు అన్ని అక్షరాలకు సరిపోయేంత పొడవు లేని మాస్టర్ వేరియబుల్‌లో SQL అక్షర విలువలను చొప్పించినట్లయితే ఇది జరుగుతుంది. ప్రామాణికం కాని డేటా రకాలైన VARCHAR మరియు LONG తో ఇది ఒక ప్రత్యేక సమస్య (అనుబంధం C చూడండి). ఈ సందర్భంలో, వేరియబుల్ స్ట్రింగ్ యొక్క మొదటి అక్షరాలతో నిండి ఉంటుంది మరియు చివరి అక్షరాలు పోతాయి. వేరియబుల్ ఇండికేటర్ ఉపయోగించినట్లయితే, అది స్ట్రింగ్ యొక్క విస్మరించిన భాగం యొక్క పొడవును సూచించే సానుకూల విలువకు సెట్ చేయబడుతుంది, తద్వారా ఎన్ని అక్షరాలు పోయాయో మీకు తెలియజేస్తుంది. ఈ సందర్భంలో, వేరియబుల్ ఇండికేటర్> 0, లేదా. యొక్క విలువను చూడటం ద్వారా మీరు తనిఖీ చేయవచ్చు< 0.

సారాంశం

SQL ఆదేశాలు రెండు విధానాల బలాన్ని కలపడానికి విధానపరమైన భాషలలో పొందుపరచబడ్డాయి. ఈ పనిని పూర్తి చేయడానికి కొన్ని అదనపు SQL టూల్స్ అవసరం. నెస్టెడ్ SQL ఆదేశాలు, ప్రీకాంపైలర్ అని పిలవబడే ప్రోగ్రామ్ ద్వారా ప్రధాన భాషా అనువాదకుడు ఉపయోగించడానికి అనువైన రూపంలోకి అనువదించబడుతుంది మరియు ఈ ప్రధాన భాషలో ప్రీకంపైలర్ సృష్టించే సబ్‌రౌటిన్‌లకు ప్రక్రియ కాల్‌గా ఉపయోగించబడుతుంది. ANSI PASCAL, FORTRAN, COBOL మరియు PL / I లలో SQL ఎంబెడింగ్‌కు మద్దతు ఇస్తుంది. ఇతర భాషలను కూడా ఉపయోగిస్తారు, ముఖ్యంగా సి. సమూహ SQL గురించి క్లుప్తంగా వివరించే ప్రయత్నంలో, ఈ అధ్యాయంలో అతి ముఖ్యమైన భాగాలు ఉన్నాయి:

* అన్ని సమూహ SQL ఆదేశాలు EXEC SQL తో ప్రారంభమవుతాయి మరియు ఉపయోగించిన హోస్ట్ భాషపై ఆధారపడి ఉండే విధంగా ముగుస్తాయి.

* SQL ఆదేశాలలో అందుబాటులో ఉన్న అన్ని ప్రధాన వేరియబుల్స్ తప్పనిసరిగా SQL డిక్లరేషన్ విభాగంలో ఉపయోగించబడకముందే ప్రకటించాలి.

* SQL కమాండ్‌లో ఉపయోగించినప్పుడు అన్ని ప్రధాన వేరియబుల్స్ తప్పనిసరిగా పెద్దప్రేగు ద్వారా ముందు ఉండాలి.

* ప్రశ్నలు ఒకే వరుసను ఎంచుకుంటే మాత్రమే INTO నిబంధనను ఉపయోగించి ప్రధాన వేరియబుల్స్‌లో వారి అవుట్‌పుట్‌ను నేరుగా నిల్వ చేయవచ్చు.

* ఒక ప్రశ్న యొక్క అవుట్‌పుట్‌ను సేవ్ చేయడానికి మరియు ఒకేసారి ఒక లైన్‌ను యాక్సెస్ చేయడానికి కర్సర్‌లను ఉపయోగించవచ్చు. కర్సర్‌లను డిక్లేర్ చేయవచ్చు (అవి కలిగి ఉన్న ప్రశ్నను వారు నిర్వచించినట్లయితే), తెరవండి (వారు ప్రశ్నను అమలు చేస్తే) మరియు మూసివేయవచ్చు (అవి కర్సర్ నుండి ప్రశ్న అవుట్‌పుట్‌ను తీసివేస్తే). కర్సర్ తెరిచినట్లయితే, ప్రశ్న అవుట్‌పుట్ యొక్క ప్రతి పంక్తికి దానిని తరలించడానికి FETCH ఆదేశం ఉపయోగించబడుతుంది.

* కర్సర్‌లు సవరించదగినవి లేదా చదవడానికి మాత్రమే. సవరించదగినదిగా మారడానికి, కర్సర్ తప్పనిసరిగా వీక్షణకు అనుగుణంగా ఉండే అన్ని ప్రమాణాలకు అనుగుణంగా ఉండాలి; ఇంకా, ఇది ఆర్డర్ బై లేదా యూనియన్ క్లాజ్‌లను ఉపయోగించకూడదు, దీనిని ఏమైనప్పటికీ వీక్షణలు ఉపయోగించలేవు. సవరించలేని కర్సర్ చదవడానికి మాత్రమే కర్సర్.

* కర్సర్ సవరించదగినది అయితే, క్లాస్ ఎక్కడ ఉన్న కరెంట్ ద్వారా గూడులో ఉన్న అప్‌డేట్ మరియు డిలీట్ కమాండ్‌ల ద్వారా ఏ అడ్డు వరుసలు ప్రభావితమవుతాయో తెలుసుకోవడానికి దాన్ని ఉపయోగించవచ్చు. తొలగింపు లేదా నవీకరణ తప్పనిసరిగా పట్టిక వెలుపల ఉండాలి, దీనిలో కర్సర్ ప్రశ్నను సూచిస్తుంది.

* SQLCODE తప్పనిసరిగా సంఖ్యా వేరియబుల్‌గా తప్పనిసరిగా Nected SQL ఉపయోగించే ప్రతి ప్రోగ్రామ్‌కి ప్రకటించబడుతుంది. ప్రతి SQL కమాండ్ అమలు చేయబడిన తర్వాత దాని విలువ స్వయంచాలకంగా సెట్ చేయబడుతుంది.

* SQL ఆదేశం యధావిధిగా అమలు చేయబడినప్పటికీ, డేటాబేస్‌లో ఎలాంటి అవుట్‌పుట్ లేదా ఆశించిన మార్పును ఉత్పత్తి చేయకపోతే, SQLCODE = 100. కమాండ్ ఒక దోషాన్ని ఉత్పత్తి చేస్తే, SQLCODE లోపాన్ని వివరించే కొన్ని హార్డ్‌వేర్ నిర్వచించిన ప్రతికూల సంఖ్యకు సమానం అవుతుంది. లేకపోతే, SQLCODE = 0.

* SQLCODE = 100 (కనుగొనబడనప్పుడు) లేదా SQLCODE ప్రతికూలంగా ఉన్నప్పుడు (SQLERROR) తీసుకోవలసిన చర్యను నిర్ణయించడానికి WENEVER నిబంధనను ఉపయోగించవచ్చు. ఈ కార్యక్రమం ప్రోగ్రామ్‌లోని నిర్దిష్ట లేబుల్‌కి జంప్ కావచ్చు (GOTO

ఈ ట్యుటోరియల్ SQL లాంగ్వేజ్ (DDL, DML) కోసం "నా మెమరీ స్టాంప్" లాంటిది, అనగా. ఇది నా వృత్తిపరమైన కార్యకలాపాల సమయంలో సేకరించిన సమాచారం మరియు నా తలలో నిరంతరం నిల్వ చేయబడుతుంది. ఇది నాకు తగినంత కనీసము, ఇది డేటాబేస్‌లతో పనిచేసేటప్పుడు ఎక్కువగా ఉపయోగించబడుతుంది. మరింత పూర్తి SQL నిర్మాణాలను ఉపయోగించడం అవసరమైతే, నేను సాధారణంగా సహాయం కోసం ఇంటర్నెట్‌లో ఉన్న MSDN లైబ్రరీని ఆశ్రయిస్తాను. నా అభిప్రాయం ప్రకారం, ప్రతిదీ మీ తలలో ఉంచడం చాలా కష్టం, మరియు దీనికి ప్రత్యేక అవసరం లేదు. కానీ ప్రాథమిక నిర్మాణాలను తెలుసుకోవడం చాలా ఉపయోగకరంగా ఉంటుంది, ఎందుకంటే ఒరాకిల్, MySQL, ఫైర్‌బర్డ్ వంటి అనేక రిలేషనల్ డేటాబేస్‌లలో అవి దాదాపు ఒకే రూపంలో వర్తిస్తాయి. వ్యత్యాసాలు ప్రధానంగా డేటా రకాల్లో ఉంటాయి, ఇవి వివరంగా భిన్నంగా ఉండవచ్చు. SQL భాష యొక్క చాలా ప్రాథమిక నిర్మాణాలు లేవు మరియు నిరంతర అభ్యాసంతో అవి త్వరగా గుర్తుకు వస్తాయి. ఉదాహరణకు, వస్తువులను (పట్టికలు, అడ్డంకులు, సూచికలు మొదలైనవి) సృష్టించడానికి, డేటాబేస్‌తో పని చేయడానికి పర్యావరణం (IDE) యొక్క టెక్స్ట్ ఎడిటర్ చేతిలో ఉంటే సరిపోతుంది మరియు దృశ్య సాధనాలను పదునుగా అధ్యయనం చేయవలసిన అవసరం లేదు నిర్దిష్ట రకం డేటాబేస్‌తో పని చేస్తోంది (MS SQL, ఒరాకిల్, MySQL, ఫైర్‌బర్డ్, ...). ఇది కూడా సౌకర్యవంతంగా ఉంటుంది ఎందుకంటే అన్ని టెక్స్ట్ మీ కళ్ల ముందు ఉంది, ఉదాహరణకు మీరు ఇండెక్స్ లేదా అడ్డంకిని సృష్టించడానికి అనేక ట్యాబ్‌ల ద్వారా అమలు చేయాల్సిన అవసరం లేదు. డేటాబేస్‌తో నిరంతర పనితో, స్క్రిప్ట్‌లను ఉపయోగించి వస్తువును సృష్టించడం, మార్చడం మరియు ప్రత్యేకించి మళ్లీ సృష్టించడం అనేది విజువల్ మోడ్‌లో చేసిన దానికంటే చాలా రెట్లు వేగంగా ఉంటుంది. స్క్రిప్ట్ మోడ్‌లో (తదనుగుణంగా, తగిన జాగ్రత్తతో), వస్తువులకు పేరు పెట్టడానికి నియమాలను సెట్ చేయడం మరియు నియంత్రించడం సులభం (నా ఆత్మాశ్రయ అభిప్రాయం). అదనంగా, ఒక డేటాబేస్‌లో (ఉదాహరణకు, ఒక పరీక్ష) చేసిన మార్పులను అదే రూపంలో మరొక (ఉత్పాదక) డేటాబేస్‌కు బదిలీ చేయాల్సిన అవసరం వచ్చినప్పుడు స్క్రిప్ట్‌లు ఉపయోగించడానికి సౌకర్యంగా ఉంటాయి.

SQL భాష అనేక భాగాలుగా విభజించబడింది, ఇక్కడ నేను దానిలోని 2 ముఖ్యమైన భాగాలను చర్చిస్తాను:

• DML - డేటా మానిప్యులేషన్ లాంగ్వేజ్, ఇందులో కింది నిర్మాణాలు ఉన్నాయి:
  • ఎంచుకోండి - డేటా ఎంపిక
  • ఇన్సర్ట్ - కొత్త డేటా చొప్పించడం
  • అప్‌డేట్ - డేటా అప్‌డేట్
  • తొలగించు - డేటాను తొలగిస్తోంది
  • MERGE - డేటా విలీనం

ఎందుకంటే నేను ఒక అభ్యాసకుడిని, ఈ ట్యుటోరియల్‌లో చిన్న సిద్ధాంతం ఉంటుంది మరియు అన్ని నిర్మాణాలు ఆచరణాత్మక ఉదాహరణలతో వివరించబడతాయి. అదనంగా, ప్రోగ్రామింగ్ లాంగ్వేజ్, మరియు ముఖ్యంగా SQL, ఆచరణలో మాత్రమే ప్రావీణ్యం పొందగలవని నేను నమ్ముతున్నాను, మీరే అనుభూతి చెందడం మరియు మీరు ఈ లేదా ఆ నిర్మాణాన్ని అమలు చేసినప్పుడు ఏమి జరుగుతుందో అర్థం చేసుకోవడం ద్వారా.

ఈ ట్యుటోరియల్ స్టెప్ బై స్టెప్ సూత్రంపై ఆధారపడింది, అనగా. ఉదాహరణలను అనుసరించి దానిని వరుసగా మరియు ప్రాధాన్యంగా వెంటనే చదవడం అవసరం. అయితే, మీరు ఆదేశం గురించి మరింత వివరంగా తెలుసుకోవాల్సిన అవసరం ఉంటే, ఇంటర్నెట్‌లో నిర్దిష్ట శోధనను ఉపయోగించండి, ఉదాహరణకు, MSDN లైబ్రరీలో.

ఈ ట్యుటోరియల్ వ్రాసేటప్పుడు, MS SQL సర్వర్ డేటాబేస్ వెర్షన్ 2014 ఉపయోగించబడింది, నేను MS SQL సర్వర్ మేనేజ్‌మెంట్ స్టూడియో (SSMS) ఉపయోగించిన స్క్రిప్ట్‌లను అమలు చేయడానికి.

MS SQL సర్వర్ మేనేజ్‌మెంట్ స్టూడియో (SSMS) గురించి క్లుప్తంగా

SQL సర్వర్ మేనేజ్‌మెంట్ స్టూడియో (SSMS) అనేది మైక్రోసాఫ్ట్ SQL సర్వర్ కోసం డేటాబేస్ భాగాలను కాన్ఫిగర్ చేయడానికి, నిర్వహించడానికి మరియు నిర్వహించడానికి ఒక యుటిలిటీ. ఈ యుటిలిటీలో స్క్రిప్ట్ ఎడిటర్ (మేము ప్రధానంగా ఉపయోగిస్తాము) మరియు సర్వర్ ఆబ్జెక్ట్‌లు మరియు సెట్టింగ్‌లతో పనిచేసే గ్రాఫికల్ ప్రోగ్రామ్ ఉంటుంది. SQL సర్వర్ మేనేజ్‌మెంట్ స్టూడియోలోని ప్రధాన సాధనం ఆబ్జెక్ట్ ఎక్స్‌ప్లోరర్, ఇది సర్వర్ వస్తువులను వీక్షించడానికి, తిరిగి పొందడానికి మరియు నిర్వహించడానికి వినియోగదారుని అనుమతిస్తుంది. ఈ వచనం పాక్షికంగా వికీపీడియా నుండి తీసుకోబడింది.

కొత్త స్క్రిప్ట్ ఎడిటర్‌ను సృష్టించడానికి, కొత్త ప్రశ్న బటన్‌ని ఉపయోగించండి:

ప్రస్తుత డేటాబేస్ మార్చడానికి, మీరు డ్రాప్-డౌన్ జాబితాను ఉపయోగించవచ్చు:

నిర్దిష్ట ఆదేశాన్ని (లేదా ఆదేశాల సమూహం) అమలు చేయడానికి, దాన్ని ఎంచుకుని, అమలు బటన్ లేదా F5 కీని నొక్కండి. ప్రస్తుతానికి ఎడిటర్‌లో ఒకే ఒక్క కమాండ్ ఉంటే, లేదా మీరు అన్ని కమాండ్‌లను ఎగ్జిక్యూట్ చేయాలి, అప్పుడు మీరు దేనినీ ఎంచుకోవాల్సిన అవసరం లేదు.

స్క్రిప్ట్‌లను అమలు చేసిన తర్వాత, ప్రత్యేకించి వస్తువులను (పట్టికలు, నిలువు వరుసలు, సూచికలు) సృష్టించిన తర్వాత, మార్పులను చూడటానికి, సందర్భ సమూహ మెను నుండి నవీకరణను ఉపయోగించండి, తగిన సమూహాన్ని (ఉదాహరణకు, పట్టికలు), పట్టిక లేదా దానిలోని నిలువు సమూహాన్ని హైలైట్ చేయండి.

వాస్తవానికి, ఇక్కడ ఇవ్వబడిన ఉదాహరణలను అమలు చేయడానికి మనం తెలుసుకోవలసినది ఇదే. మిగిలిన SSMS యుటిలిటీ మీ స్వంతంగా నేర్చుకోవడం సులభం.

కొంచెం సిద్ధాంతం

ఒక రిలేషనల్ డేటాబేస్ (RDB, లేదా మరింత కేవలం ఒక డేటాబేస్ సందర్భంలో) అనేది ఒకదానితో ఒకటి అనుసంధానించబడిన పట్టికల సమాహారం. స్థూలంగా చెప్పాలంటే, డేటాబేస్ అనేది ఫైల్‌ను నిర్మాణాత్మక రూపంలో నిల్వ చేసే ఫైల్.

DBMS అనేది ఈ డేటాబేస్‌ల నిర్వహణ వ్యవస్థ, అనగా. ఇది ఒక నిర్దిష్ట రకం డేటాబేస్ (MS SQL, Oracle, MySQL, Firebird, ...) తో పనిచేసే సాధనాల సమితి.

గమనిక
ఎందుకంటే జీవితంలో, వ్యావహారిక ప్రసంగంలో, మనం ఎక్కువగా చెబుతాము: "ఒరాకిల్ డిబి", లేదా కేవలం "ఒరాకిల్", వాస్తవానికి "ఒరాకిల్ డిబిఎంఎస్" అని అర్ధం, అప్పుడు ఈ ట్యుటోరియల్ సందర్భంలో డిబి అనే పదం కొన్నిసార్లు ఉపయోగించబడుతుంది. సందర్భం నుండి, ఇది దేని గురించి స్పష్టంగా ఉంటుందో నేను అనుకుంటున్నాను.

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

RDB యొక్క ప్రధాన వస్తువు పట్టిక, అన్ని RDB డేటా పట్టికలోని నిలువు వరుసలలో వరుసగా నిల్వ చేయబడుతుంది. తీగలు, రికార్డులు కూడా పర్యాయపదాలు.

ప్రతి పట్టిక కోసం, అలాగే దాని నిలువు వరుసల కోసం, పేర్లు ఇవ్వబడ్డాయి, దీని ద్వారా అవి తరువాత యాక్సెస్ చేయబడతాయి.
MS SQL లో ఒక వస్తువు పేరు (పట్టిక పేరు, కాలమ్ పేరు, సూచిక పేరు మొదలైనవి) గరిష్టంగా 128 అక్షరాల పొడవు ఉంటుంది.

సూచన కొరకు- ORACLE డేటాబేస్‌లో, ఆబ్జెక్ట్ పేర్లు గరిష్టంగా 30 అక్షరాల పొడవును కలిగి ఉంటాయి. అందువల్ల, నిర్దిష్ట డేటాబేస్ కోసం, అక్షరాల సంఖ్యపై పరిమితిని ఉంచడానికి మీరు వస్తువులకు పేరు పెట్టడానికి మీ స్వంత నియమాలను అభివృద్ధి చేసుకోవాలి.

SQL అనేది DBMS ఉపయోగించి డేటాబేస్‌లో ప్రశ్నలను అమలు చేయడానికి మిమ్మల్ని అనుమతించే భాష. నిర్దిష్ట DBMS లో, SQL భాష నిర్దిష్ట అమలును కలిగి ఉంటుంది (దాని స్వంత యాస).

DDL మరియు DML లు SQL భాష యొక్క ఉపసమితి:

• DDL భాష డేటాబేస్ నిర్మాణాన్ని సృష్టించడానికి మరియు సవరించడానికి ఉపయోగించబడుతుంది, అనగా. పట్టికలు మరియు లింక్‌లను సృష్టించడానికి / సవరించడానికి / తొలగించడానికి.
• DML భాష పట్టిక డేటా యొక్క తారుమారుని అనుమతిస్తుంది, అనగా. ఆమె పంక్తులతో. ఇది పట్టికల నుండి డేటాను ఎంచుకోవడానికి, పట్టికలకు కొత్త డేటాను జోడించడానికి మరియు ఇప్పటికే ఉన్న డేటాను నవీకరించడానికి మరియు తొలగించడానికి మిమ్మల్ని అనుమతిస్తుంది.

SQL (సింగిల్-లైన్ మరియు మల్టీ-లైన్) లో ఉపయోగించే 2 రకాల వ్యాఖ్యలు ఉన్నాయి:

సింగిల్ లైన్ వ్యాఖ్య
మరియు

/ * బహుళ-లైన్ వ్యాఖ్య * /

వాస్తవానికి, సిద్ధాంతానికి ఇది సరిపోతుంది.

DDL - డేటా నిర్వచన భాష

ఉదాహరణకు, ప్రోగ్రామర్ కాని వ్యక్తికి సాధారణ రూపంలో, ఉద్యోగుల గురించి డేటాతో కూడిన పట్టికను పరిగణించండి:

ఈ సందర్భంలో, పట్టిక నిలువు వరుసలకు ఈ క్రింది పేర్లు ఉన్నాయి: సిబ్బంది సంఖ్య, పూర్తి పేరు, పుట్టిన తేదీ, ఇ-మెయిల్, స్థానం, విభాగం.

ఈ నిలువు వరుసలలో ప్రతి దానిలోని డేటా రకం ద్వారా వర్గీకరించవచ్చు:

• సిబ్బంది సంఖ్య - పూర్ణాంకం
• పూర్తి పేరు - స్ట్రింగ్
• పుట్టిన తేదీ - తేదీ
• ఇ -మెయిల్ - స్ట్రింగ్
• స్థానం - స్ట్రింగ్
• విభాగం - స్ట్రింగ్

కాలమ్ రకం అనేది ఒక నిర్దిష్ట కాలమ్ ఏ రకమైన డేటాను నిల్వ చేయగలదో చెప్పే లక్షణం.

ప్రారంభించడానికి, MS SQL లో ఉపయోగించే కింది ప్రాథమిక డేటా రకాలను మాత్రమే గుర్తుంచుకోవడం సరిపోతుంది:

అర్థం	MS SQL సంజ్ఞామానం	వివరణ
వేరియబుల్ పొడవు స్ట్రింగ్	వర్చార్ (N) మరియు nvarchar (N)	N సంఖ్యతో, మేము సంబంధిత కాలమ్ కోసం గరిష్టంగా సాధ్యమయ్యే వరుస పొడవును పేర్కొనవచ్చు. ఉదాహరణకు, "పేరు" కాలమ్ విలువ గరిష్టంగా 30 అక్షరాలను కలిగి ఉంటుందని మేము చెప్పాలనుకుంటే, దానిని మనం nvarchar (30) రకానికి సెట్ చేయాలి. వర్చార్ మరియు ఎన్‌వార్చర్ మధ్య వ్యత్యాసం ఏమిటంటే, వార్చార్ స్ట్రింగ్‌లను ASCII ఫార్మాట్‌లో నిల్వ చేస్తుంది, ఇక్కడ ఒక అక్షరం 1 బైట్, అయితే nvarchar స్ట్రింగ్‌లను యునికోడ్ ఫార్మాట్‌లో నిల్వ చేస్తుంది, ఇక్కడ ప్రతి అక్షరం 2 బైట్‌లు. ఈ ఫీల్డ్‌లో యునికోడ్ అక్షరాలను నిల్వ చేయాల్సిన అవసరం లేదని మీకు 100% ఖచ్చితంగా తెలిస్తే మాత్రమే వర్చార్ రకాన్ని ఉపయోగించాలి. ఉదాహరణకు, ఇమెయిల్ చిరునామాలను నిల్వ చేయడానికి వార్చార్‌ను ఉపయోగించవచ్చు ఎందుకంటే అవి సాధారణంగా ASCII అక్షరాలను మాత్రమే కలిగి ఉంటాయి.
స్థిర పొడవు స్ట్రింగ్	చార్ (ఎన్) మరియు nchar (N)	ఈ రకం వేరియబుల్-లెంగ్త్ స్ట్రింగ్‌కి భిన్నంగా ఉంటుంది, దీనిలో స్ట్రింగ్ యొక్క పొడవు N అక్షరాల కంటే తక్కువగా ఉంటే, అది ఎల్లప్పుడూ N వరకు నిడివి వరకు ఖాళీలతో ప్యాడ్ చేయబడుతుంది మరియు ఈ రూపంలో డేటాబేస్‌లో నిల్వ చేయబడుతుంది, అనగా. ఇది డేటాబేస్‌లో ఖచ్చితంగా N అక్షరాలను ఆక్రమిస్తుంది (ఇక్కడ ఒక అక్షరం చార్ కోసం 1 బైట్ మరియు nchar కోసం 2 బైట్‌లను ఆక్రమిస్తుంది). నా ఆచరణలో, ఈ రకం చాలా అరుదుగా ఉపయోగించబడుతుంది, మరియు అది ఉపయోగించినట్లయితే, అది ప్రధానంగా చార్ (1) ఫార్మాట్‌లో ఉపయోగించబడుతుంది, అనగా. ఫీల్డ్ ఒక అక్షరం ద్వారా నిర్వచించబడినప్పుడు.
పూర్ణ సంఖ్య	int	ఈ రకం కాలమ్‌లో పాజిటివ్ మరియు నెగటివ్ రెండింటిని మాత్రమే పూర్ణాంకాలను ఉపయోగించడానికి అనుమతిస్తుంది. సూచన కోసం (ఇప్పుడు ఇది మాకు అంత సంబంధితంగా లేదు) - int రకం అనుమతించే సంఖ్యల పరిధి -2 147 483 648 నుండి 2 147 483 647 వరకు ఉంటుంది. సాధారణంగా ఇది ఐడెంటిఫైయర్‌లను సెట్ చేయడానికి ఉపయోగించే ప్రధాన రకం.
వాస్తవ లేదా వాస్తవ సంఖ్య	తేలుతాయి	సరళంగా చెప్పాలంటే, ఇవి దశాంశ బిందువు (కామా) ఉండే సంఖ్యలు.
తేదీ	తేదీ	కాలమ్‌లో తేదీని మాత్రమే నిల్వ చేయడం అవసరమైతే, ఇందులో మూడు భాగాలు ఉంటాయి: సంఖ్య, నెల మరియు సంవత్సరం. ఉదాహరణకు, 02/15/2014 (ఫిబ్రవరి 15, 2014). ఈ రకం కాలమ్ "అడ్మిషన్ తేదీ", "పుట్టిన తేదీ" మొదలైన వాటి కోసం ఉపయోగించవచ్చు. సందర్భాలలో మనం తేదీని మాత్రమే సరిచేయడం ముఖ్యం, లేదా సమయ భాగం మనకు ముఖ్యం కానప్పుడు మరియు దానిని విస్మరించవచ్చు లేదా తెలియకపోతే.
సమయం	సమయం	కాలమ్‌లో మాత్రమే డేటాను నిల్వ చేయాల్సిన అవసరం ఉంటే ఈ రకాన్ని ఉపయోగించవచ్చు, అనగా. గంటలు, నిమిషాలు, సెకన్లు మరియు మిల్లీసెకన్లు. ఉదాహరణకు, 17:38: 31.3231603 ఉదాహరణకు, రోజువారీ "ఫ్లైట్ డిపార్చర్ టైమ్".
తేదీ మరియు సమయం	తేదీ సమయం	ఈ రకం మీరు ఒకేసారి తేదీ మరియు సమయం రెండింటినీ సేవ్ చేయడానికి అనుమతిస్తుంది. ఉదాహరణకు, 02/15/2014 17: 38: 31.323 ఉదాహరణకు, ఇది ఈవెంట్ యొక్క తేదీ మరియు సమయం కావచ్చు.
జెండా	బిట్	"అవును" / "లేదు" వంటి విలువలను నిల్వ చేయడానికి ఈ రకం సౌకర్యవంతంగా ఉంటుంది, ఇక్కడ "అవును" 1 గా నిల్వ చేయబడుతుంది మరియు "లేదు" 0 గా నిల్వ చేయబడుతుంది.

అలాగే, ఫీల్డ్ విలువ, అది నిషేధించబడకపోతే, పేర్కొనబడకపోవచ్చు, ఈ ప్రయోజనం కోసం NULL అనే కీవర్డ్ ఉపయోగించబడుతుంది.

ఉదాహరణలను అమలు చేయడానికి, పరీక్ష అనే పరీక్ష స్థావరాన్ని సృష్టిద్దాం.

కింది ఆదేశాన్ని అమలు చేయడం ద్వారా సాధారణ డేటాబేస్ (అదనపు పారామితులను పేర్కొనకుండా) సృష్టించవచ్చు:

డేటాబేస్ పరీక్షను సృష్టించండి
మీరు కమాండ్‌తో డేటాబేస్‌ను తొలగించవచ్చు (ఈ ఆదేశంతో మీరు చాలా జాగ్రత్తగా ఉండాలి):

డ్రాప్ డేటాబేస్ టెస్ట్
మా డేటాబేస్‌కు మారడానికి, మీరు ఆదేశాన్ని అమలు చేయవచ్చు:

USE పరీక్ష
ప్రత్యామ్నాయంగా, SSMS మెను ప్రాంతంలోని డ్రాప్-డౌన్ జాబితా నుండి పరీక్ష డేటాబేస్‌ను ఎంచుకోండి. పని చేసేటప్పుడు, నేను తరచుగా స్థావరాల మధ్య మారే ఈ పద్ధతిని ఉపయోగిస్తాను.

ఇప్పుడు మా డేటాబేస్‌లో ఖాళీలు మరియు సిరిలిక్ అక్షరాలను ఉపయోగించి వివరణలను ఉపయోగించి పట్టికను సృష్టించవచ్చు:

టేబుల్ [ఉద్యోగులు] ([సిబ్బంది సంఖ్య] int, [పూర్తి పేరు] nvarchar (30), [పుట్టిన తేదీ] తేదీ, nvarchar (30), [స్థానం] nvarchar (30), [విభాగం] nvarchar (30))
ఈ సందర్భంలో, మేము పేర్లను చదరపు బ్రాకెట్లలో జత చేయాలి [...].

కానీ డేటాబేస్‌లో, ఎక్కువ సౌలభ్యం కోసం, లాటిన్ వర్ణమాలలో అన్ని ఆబ్జెక్ట్ పేర్లను పేర్కొనడం మంచిది మరియు పేర్లలో ఖాళీలను ఉపయోగించకూడదు. MS SQL లో, సాధారణంగా ఈ సందర్భంలో, ప్రతి పదం పెద్ద అక్షరంతో ప్రారంభమవుతుంది, ఉదాహరణకు, "పర్సనల్ నంబర్" ఫీల్డ్ కోసం, మేము పర్సనల్ నంబర్ అనే పేరును పేర్కొనవచ్చు. మీరు పేరులోని సంఖ్యలను కూడా ఉపయోగించవచ్చు, ఉదాహరణకు, ఫోన్ నంబర్ 1.

నోట్లో
కొన్ని DBMS లో, కింది నామకరణ ఫార్మాట్ "PHONE_NUMBER" మరింత ప్రాధాన్యతనిస్తుంది, ఉదాహరణకు, ఈ ఫార్మాట్ తరచుగా ORACLE DB లో ఉపయోగించబడుతుంది. సహజంగానే, ఫీల్డ్ పేరును పేర్కొన్నప్పుడు, ఇది DBMS లో ఉపయోగించే కీలకపదాలతో ఏకీభవించకపోవడం మంచిది.

ఈ కారణంగా, మీరు చదరపు బ్రాకెట్ల వాక్యనిర్మాణం గురించి మరచిపోవచ్చు మరియు [ఉద్యోగులు] పట్టికను తొలగించవచ్చు:

డ్రాప్ టేబుల్ [ఉద్యోగులు]
ఉదాహరణకు, ఉద్యోగులతో ఉన్న టేబుల్‌కు "ఎంప్లాయిస్" అని పేరు పెట్టవచ్చు మరియు దాని ఫీల్డ్‌లకు ఈ క్రింది విధంగా పేరు పెట్టవచ్చు:

• ID - సిబ్బంది సంఖ్య (ఉద్యోగి ID)
• పేరు - పూర్తి పేరు
• పుట్టినరోజు - పుట్టిన తేదీ
• ఇమెయిల్ - ఇమెయిల్
• స్థానం - స్థానం
• విభాగం - విభాగం

చాలా తరచుగా ID అనే పదం ఐడెంటిఫైయర్ ఫీల్డ్‌కు పేరు పెట్టడానికి ఉపయోగించబడుతుంది.

ఇప్పుడు మన పట్టికను సృష్టిద్దాం:

టేబుల్ ఉద్యోగులను సృష్టించు
తప్పనిసరి కాలమ్‌లను పేర్కొనడానికి మీరు NOT NULL ఎంపికను ఉపయోగించవచ్చు.

ఇప్పటికే ఉన్న పట్టిక కోసం, కింది ఆదేశాలను ఉపయోగించి ఫీల్డ్‌లను పునర్నిర్వచించవచ్చు:

ఐడి ఫీల్డ్‌ని అప్‌డేట్ చేయడం, మొత్తం టేబుల్ ఐడి అంతిమంగా పూర్తి కాదు - పేరు ఫీల్డ్‌ని అప్‌డేట్ చేయడం, మొత్తం టేబుల్ ఉద్యోగుల పేరు పేరు nvarchar (30) శూన్యము

నోట్లో
చాలా DBMS ల కోసం SQL భాష యొక్క సాధారణ భావన అలాగే ఉంటుంది (కనీసం, నేను పని చేసిన DBMS ల ద్వారా నేను దీనిని నిర్ధారించగలను). వివిధ DBMS లలో DDL మధ్య వ్యత్యాసం ప్రధానంగా డేటా రకాల్లో ఉంటుంది (ఇక్కడ వారి పేర్లు మాత్రమే కాకుండా, వాటి అమలు వివరాలు కూడా ఉంటాయి), SQL భాష అమలు ప్రత్యేకతలు కూడా కొద్దిగా భిన్నంగా ఉండవచ్చు (అనగా సారాంశం ఆదేశాలు ఒకటే, కానీ మాండలికంలో స్వల్ప తేడాలు ఉండవచ్చు, అయ్యో, కానీ ఒక ప్రమాణం లేదు). SQL యొక్క ప్రాథమికాలను తెలుసుకోవడం, మీరు సులభంగా ఒక DBMS నుండి మరొకదానికి మారవచ్చు, ఎందుకంటే ఈ సందర్భంలో, మీరు కొత్త DBMS లో ఆదేశాల అమలు వివరాలను మాత్రమే అర్థం చేసుకోవాలి, అనగా. చాలా సందర్భాలలో, ఒక సాధారణ సారూప్యత సరిపోతుంది.

టేబుల్ క్రియేట్ టేబుల్ ఉద్యోగులను సృష్టించండి (ID int, - ORACLE లో, int రకం సంఖ్యకు సమానమైనది (రేపర్) (38) పేరు nvarchar2 (30), - ORACLE లో nvarchar2 అనేది MS SQL పుట్టినరోజు తేదీలో nvarchar కు సమానం, ఇమెయిల్ nvarchar2 ( 30), స్థానం nvarchar2 (30), విభాగం nvarchar2 (30)); - ID మరియు పేరు ఫీల్డ్‌లను అప్‌డేట్ చేయడం (ఇక్కడ కాలమ్‌కు బదులుగా MODIFY (...) ఉపయోగించబడుతుంది) టేబుల్ ఉద్యోగుల మోడిఫీ (ID పూర్తిగా కాదు, పేరు nvarchar2 (30) శూన్యమైనది కాదు); - PK ని జోడించడం (ఈ సందర్భంలో, నిర్మాణం MS SQL లో కనిపిస్తుంది, ఇది క్రింద చూపబడుతుంది) ఆల్టర్ టేబుల్ ఉద్యోగులు కన్స్ట్రెంట్ PK_Employees ప్రైమరీ కీ (ID) జోడించండి;
ORACLE కోసం, varchar2 రకం అమలు పరంగా తేడాలు ఉన్నాయి, దాని ఎన్‌కోడింగ్ డేటాబేస్ సెట్టింగ్‌లపై ఆధారపడి ఉంటుంది మరియు టెక్స్ట్ సేవ్ చేయవచ్చు, ఉదాహరణకు, UTF-8 ఎన్‌కోడింగ్‌లో. అదనంగా, ORACLE లో ఫీల్డ్ పొడవు బైట్‌లు మరియు అక్షరాలలో పేర్కొనవచ్చు, దీని కోసం, అదనపు BYTE మరియు CHAR ఎంపికలు ఉపయోగించబడతాయి, ఇవి ఫీల్డ్ పొడవు తర్వాత పేర్కొనబడ్డాయి, ఉదాహరణకు:

NAME varchar2 (30 BYTE) - ఫీల్డ్ సామర్థ్యం 30 బైట్లు NAME varchar2 (30 CHAR) - ఫీల్డ్ సామర్థ్యం 30 అక్షరాలు
ORACLE లో varchar2 (30) రకం యొక్క సాధారణ సూచన విషయంలో డిఫాల్ట్‌గా BYTE లేదా CHAR ద్వారా ఏ ఆప్షన్ ఉపయోగించబడుతుంది, డేటాబేస్ సెట్టింగ్‌లపై ఆధారపడి ఉంటుంది, ఇది కొన్నిసార్లు IDE సెట్టింగ్‌లలో కూడా సెట్ చేయబడుతుంది. సాధారణంగా, కొన్నిసార్లు మీరు సులభంగా గందరగోళానికి గురవుతారు, కాబట్టి ORACLE విషయంలో, varchar2 రకం ఉపయోగించినట్లయితే (మరియు ఇది కొన్నిసార్లు ఇక్కడ సమర్థించబడుతోంది, ఉదాహరణకు, UTF-8 ఎన్‌కోడింగ్ ఉపయోగిస్తున్నప్పుడు), నేను స్పష్టంగా CHAR రాయడానికి ఇష్టపడతాను (అప్పటి నుండి అక్షరాలలో స్ట్రింగ్ పొడవు చదవడం సాధారణంగా మరింత సౌకర్యవంతంగా ఉంటుంది).

కానీ ఈ సందర్భంలో, పట్టికలో ఇప్పటికే కొంత డేటా ఉంటే, ఆదేశాలను విజయవంతంగా అమలు చేయడానికి పట్టికలోని అన్ని వరుసలలోని ID మరియు పేరు ఫీల్డ్‌లు తప్పనిసరిగా పూరించాలి. దీనిని ఉదాహరణతో ప్రదర్శిద్దాం, ID, పొజిషన్ మరియు డిపార్ట్‌మెంట్ ఫీల్డ్‌లలోని పట్టికలో డేటాను చొప్పించండి, ఇది క్రింది స్క్రిప్ట్‌తో చేయవచ్చు:

INSERT ఉద్యోగులు (ID, స్థానం, విభాగం) విలువలు (1000, N "డైరెక్టర్", N "అడ్మినిస్ట్రేషన్"), (1001, N "ప్రోగ్రామర్", N "IT"), (1002, N "అకౌంటెంట్", N "అకౌంటింగ్" ), (1003, N "సీనియర్ ప్రోగ్రామర్", N "IT")
ఈ సందర్భంలో, INSERT కమాండ్ కూడా ఒక లోపాన్ని సృష్టిస్తుంది చొప్పించేటప్పుడు, అవసరమైన పేరు ఫీల్డ్ విలువను మేము పేర్కొనలేదు.
మేము ఇప్పటికే ఈ డేటాను అసలైన పట్టికలో కలిగి ఉంటే, "ఆల్టర్ టేబుల్ ఎంప్లాయిస్ ఆల్టర్ కాలమ్ ఐడి నంట్ నల్" అనే కమాండ్ విజయవంతంగా పూర్తవుతుంది, మరియు "ఆల్టర్ టేబుల్ ఎంప్లాయీస్ ఆల్టర్ కాలమ్ పేరు ఇంట్ నాట్ నల్" అనే కమాండ్ ఒక ఎర్రర్ మెసేజ్‌ని రూపొందిస్తుంది , పేరు ఫీల్డ్‌లో NULL (పేర్కొనబడని) విలువలు ఉన్నాయని.

పేరు ఫీల్డ్ కోసం విలువలను జోడించి, డేటాను మళ్లీ పూరించండి:

అలాగే, కొత్త పట్టికను సృష్టించేటప్పుడు NOT NULL ఎంపికను నేరుగా ఉపయోగించవచ్చు, అనగా. CREATE Table ఆదేశం సందర్భంలో.

ముందుగా, ఆదేశాన్ని ఉపయోగించి పట్టికను తొలగిద్దాం:

టేబుల్ ఉద్యోగులను డ్రాప్ చేయండి
ఇప్పుడు తప్పనిసరిగా నిలువు వరుసల ID మరియు పేరుతో పట్టికను సృష్టిద్దాం:

టేబుల్ ఉద్యోగులను సృష్టించండి (ID పూర్తి కాదు
కాలమ్ పేరు తర్వాత మీరు NULL ను కూడా వ్రాయవచ్చు, అంటే దీనిలో NULL విలువలు (పేర్కొనబడలేదు) అనుమతించబడతాయి, అయితే ఇది అవసరం లేదు, ఎందుకంటే ఈ లక్షణం అప్రమేయంగా భావించబడుతుంది.

ఒకవేళ, దీనికి విరుద్ధంగా, నింపడానికి ఇప్పటికే ఉన్న కాలమ్‌ను ఐచ్ఛికం చేయడం అవసరమైతే, మేము ఈ కింది కమాండ్ వాక్యనిర్మాణాన్ని ఉపయోగిస్తాము:

మొత్తం టేబుల్ ఉద్యోగుల ఆల్టర్ కాలమ్ పేరు nvarchar (30) శూన్యం
లేదా కేవలం:

ఆల్టర్ టేబుల్ ఉద్యోగులు ఆల్టర్ కాలమ్ పేరు nvarchar (30)
అలాగే, ఈ ఆదేశంతో, మేము ఫీల్డ్ రకాన్ని మరొక అనుకూల రకానికి మార్చవచ్చు లేదా దాని పొడవును మార్చవచ్చు. ఉదాహరణకు, నేమ్ ఫీల్డ్‌ను 50 అక్షరాలకు విస్తరిద్దాం:

ఆల్టర్ టేబుల్ ఉద్యోగులు ఆల్టర్ కాలమ్ పేరు nvarchar (50)

ప్రాథమిక కీ

పట్టికను సృష్టించేటప్పుడు, దాని యొక్క ప్రతి అడ్డు వరుసకు ప్రత్యేకమైన నిలువు వరుస లేదా నిలువు వరుసల సమితిని కలిగి ఉండటం మంచిది - ఈ ప్రత్యేక విలువ ద్వారా రికార్డును ప్రత్యేకంగా గుర్తించవచ్చు. ఈ విలువను పట్టిక ప్రాథమిక కీ అంటారు. మా ఉద్యోగుల పట్టిక కోసం, అటువంటి విశిష్ట విలువ ID కాలమ్ కావచ్చు (ఇందులో "ఎంప్లాయీ పర్సనల్ నంబర్" ఉంటుంది - మా విషయంలో ఈ విలువ ప్రతి ఉద్యోగికి ప్రత్యేకంగా ఉంటుంది మరియు పునరావృతం చేయబడదు).

ఆదేశాన్ని ఉపయోగించి మీరు ఇప్పటికే ఉన్న పట్టికకు ప్రాథమిక కీని సృష్టించవచ్చు:

ఆల్టర్ టేబుల్ ఉద్యోగులు అనుబంధ PK_EPloyees ప్రైమరీ కీ (ID) ని జోడిస్తారు
ప్రాథమిక కీకి బాధ్యత వహించే పరిమితి పేరు "PK_Employees". సాధారణంగా, "PK_" ఉపసర్గ ప్రాథమిక కీకి పేరు పెట్టడానికి ఉపయోగించబడుతుంది, తరువాత పట్టిక పేరు ఉంటుంది.

ప్రాథమిక కీ అనేక ఫీల్డ్‌లను కలిగి ఉంటే, ఈ ఫీల్డ్‌లు తప్పనిసరిగా కామాలతో వేరు చేయబడిన కుండలీకరణాల్లో జాబితా చేయబడాలి:

టేబుల్ టేబుల్_పేరు జోడించండి CONSTRAINT పరిమితి_పేరు ప్రాథమిక కీ
MS SQL లో, ప్రాథమిక కీలో చేర్చబడిన అన్ని ఫీల్డ్‌లు తప్పనిసరిగా శూన్యంగా ఉండవని గమనించాలి.

అలాగే, పట్టికను సృష్టించేటప్పుడు ప్రాథమిక కీని నేరుగా నిర్వచించవచ్చు, అనగా. CREATE TABLE ఆదేశం సందర్భంలో. పట్టికను తొలగిద్దాం:

టేబుల్ ఉద్యోగులను డ్రాప్ చేయండి
ఆపై మేము దీనిని కింది వాక్యనిర్మాణాన్ని ఉపయోగించి సృష్టిస్తాము:

టేబుల్ ఉద్యోగులను సృష్టించండి (ID పూర్తి కాదు ఫీల్డ్‌లు పరిమితిగా)
సృష్టించిన తర్వాత, మేము డేటాను పట్టికలో పూరిస్తాము:

INSERT ఉద్యోగులు (ID, స్థానం, విభాగం, పేరు) విలువలు (1000, N "డైరెక్టర్", N "అడ్మినిస్ట్రేషన్", N "ఇవనోవ్ I.I."), (1001, N "ప్రోగ్రామర్", N "IT", N "పెట్రోవ్ PP" ), (1002, N "అకౌంటెంట్", N "అకౌంటింగ్", N "సిడోరోవ్ SS"), (1003, N "సీనియర్ ప్రోగ్రామర్", N "IT", N "ఆండ్రీవ్ A. A.")
పట్టికలోని ప్రాథమిక కీ ఒక కాలమ్ విలువలను మాత్రమే కలిగి ఉంటే, కింది వాక్యనిర్మాణాన్ని ఉపయోగించవచ్చు:

టేబుల్ ఉద్యోగులను సృష్టించండి (ID int NULL CONSTRAINT PK_Employees PIMARY KEY, - ఫీల్డ్ యొక్క లక్షణంగా పేర్కొనండి పేరు nvarchar (30) NULL కాదు, పుట్టినరోజు తేదీ, ఇమెయిల్ nvarchar (30), పొజిషన్ nvarchar (30)
వాస్తవానికి, పరిమితి పేరును విస్మరించవచ్చు, ఈ సందర్భంలో దానికి సిస్టమ్ పేరు కేటాయించబడుతుంది ("PK__Employee__3214EC278DA42077" వంటివి):

టేబుల్ ఉద్యోగులను సృష్టించండి (ID పూర్తి కాదు
లేదా:

టేబుల్ ఉద్యోగులను సృష్టించు
కానీ నిరంతర పట్టికల కోసం నిర్బంధ పేరును స్పష్టంగా పేర్కొనాలని నేను సిఫార్సు చేస్తున్నాను స్పష్టంగా ఇచ్చిన మరియు అర్థమయ్యే పేరు ద్వారా, దానిని తారుమారు చేయడం సులభం అవుతుంది, ఉదాహరణకు, మీరు దీన్ని తొలగించవచ్చు:

పట్టిక ఉద్యోగుల డ్రాప్ కాంట్రాక్ట్ పికె_ఉద్యోగులు
కానీ అలాంటి చిన్న వాక్యనిర్మాణం, పరిమితుల పేర్లను పేర్కొనకుండా, తాత్కాలిక డేటాబేస్ పట్టికలను సృష్టించేటప్పుడు ఉపయోగించడానికి సౌకర్యంగా ఉంటుంది (తాత్కాలిక పట్టిక పేరు #లేదా ## తో మొదలవుతుంది), ఉపయోగం తర్వాత తొలగించబడుతుంది.

సంగ్రహంగా చూద్దాం

ఇప్పటివరకు మేము ఈ క్రింది ఆదేశాలను చూశాము:

• పట్టికను సృష్టించండి table_name (ఫీల్డ్‌లు మరియు వాటి రకాలు, ఆంక్షలు) - ప్రస్తుత డేటాబేస్‌లో కొత్త పట్టికను రూపొందించడానికి ఉపయోగపడుతుంది;
• డ్రాప్ టేబుల్ table_name - ప్రస్తుత డేటాబేస్ నుండి పట్టికను తొలగించడానికి ఉపయోగపడుతుంది;
• పట్టికటేబుల్_పేరు ఆల్టర్ కాలమ్కాలమ్_పేరు ... - కాలమ్ రకాన్ని అప్‌డేట్ చేయడానికి లేదా దాని సెట్టింగ్‌లను మార్చడానికి ఉపయోగించబడుతుంది (ఉదాహరణకు, శూన్యమైన లేదా శూన్య లక్షణాన్ని పేర్కొనడానికి);
• పట్టికటేబుల్_పేరు నిర్మాణాన్ని జోడించండినిర్బంధం_పేరు ప్రాథమిక కీ(ఫీల్డ్ 1, ఫీల్డ్ 2, ...) - ఇప్పటికే ఉన్న టేబుల్‌కు ప్రాథమిక కీని జోడించడం;
• పట్టికటేబుల్_పేరు డ్రాప్ నిర్మాణం constraint_name - పట్టిక నుండి అడ్డంకిని తొలగిస్తుంది.

తాత్కాలిక పట్టికల గురించి కొంచెం

MSDN నుండి సారాంశం. MS SQL సర్వర్‌లో రెండు రకాల తాత్కాలిక పట్టికలు ఉన్నాయి: లోకల్ (#) మరియు గ్లోబల్ (##). స్థానిక తాత్కాలిక పట్టికలు SQL సర్వర్ ఉదాహరణకి కనెక్షన్ ముగిసే వరకు వారి సృష్టికర్తలకు మాత్రమే కనిపిస్తాయి, అవి మొదట సృష్టించబడిన వెంటనే. SQL సర్వర్ యొక్క ఉదాహరణ నుండి వినియోగదారు డిస్‌కనెక్ట్ చేసిన తర్వాత స్థానిక తాత్కాలిక పట్టికలు స్వయంచాలకంగా తొలగించబడతాయి. ఈ పట్టికలు సృష్టించబడిన తర్వాత ఏదైనా కనెక్షన్ సెషన్‌లలో వినియోగదారులందరికీ గ్లోబల్ తాత్కాలిక పట్టికలు కనిపిస్తాయి మరియు ఈ పట్టికలను సూచించే వినియోగదారులందరూ SQL సర్వర్ ఉదాహరణ నుండి డిస్‌కనెక్ట్ చేసినప్పుడు తొలగించబడతారు.

తాత్కాలిక పట్టికలు tempdb సిస్టమ్ డేటాబేస్‌లో సృష్టించబడ్డాయి, అనగా. వాటిని సృష్టించడం ద్వారా, మేము ప్రధాన స్థావరాన్ని చెత్తాచెదారం చేయము, లేకుంటే తాత్కాలిక పట్టికలు సాధారణ పట్టికలకు పూర్తిగా సమానంగా ఉంటాయి, వాటిని డ్రాప్ టేబుల్ కమాండ్ ఉపయోగించి కూడా వదలవచ్చు. స్థానిక (#) తాత్కాలిక పట్టికలు ఎక్కువగా ఉపయోగించబడతాయి.

తాత్కాలిక పట్టికను సృష్టించడానికి మీరు CREATE TABLE ఆదేశాన్ని ఉపయోగించవచ్చు:

టేబుల్ #టెంప్‌ని రూపొందించండి (ID int, పేరు nvarchar (30))
MS SQL లో తాత్కాలిక పట్టిక సాధారణ పట్టికను పోలి ఉంటుంది కాబట్టి, డ్రాప్ టేబుల్ కమాండ్‌తో మీరు దానిని మీరే డ్రాప్ చేయవచ్చు:

టేబుల్ #టెంప్ డ్రాప్ చేయండి

అలాగే, తాత్కాలిక పట్టికను (ఒక సాధారణ పట్టిక వలె) సృష్టించవచ్చు మరియు వెంటనే సెలెక్ట్‌ని ఉపయోగించి ప్రశ్న ద్వారా తిరిగి ఇవ్వబడిన డేటాతో నింపవచ్చు ... సింటాక్స్:

ఐడీని ఎంచుకోండి, ఉద్యోగుల నుండి #టెంప్‌లోకి పేరు

నోట్లో
తాత్కాలిక పట్టికల అమలు వివిధ DBMS లలో వేరుగా ఉండవచ్చు. ఉదాహరణకు, ORACLE మరియు Firebird DBMS లో, తాత్కాలిక పట్టికల నిర్మాణం తప్పనిసరిగా క్రియేట్ గ్లోబల్ టెంపోరీ టేబుల్ కమాండ్‌తో ముందుగానే నిర్వచించబడాలి, దానిలో డేటాను నిల్వ చేసే ప్రత్యేకతలు సూచిస్తాయి, అప్పుడు వినియోగదారు దానిని ప్రధాన పట్టికల మధ్య చూడవచ్చు మరియు దానితో పని చేయవచ్చు సాధారణ పట్టికతో.

డేటాబేస్ సాధారణీకరణ - సబ్‌టేబుల్స్ (డైరెక్టరీలు) మరియు సంబంధాలను నిర్వచించడం

మా ప్రస్తుత ఉద్యోగుల పట్టికలో వినియోగదారుడు పొజిషన్ మరియు డిపార్ట్‌మెంట్ ఫీల్డ్‌లలో ఏదైనా టెక్స్ట్‌ని నమోదు చేయగల ప్రతికూలత ఉంది, ఇది మొదటి స్థానంలో లోపాలతో కూడి ఉంటుంది, ఎందుకంటే ఒక ఉద్యోగి "IT" ని ఒక డిపార్ట్‌మెంట్‌గా మరియు రెండవ ఉద్యోగిగా పేర్కొనవచ్చు. ఉదాహరణకు, మూడవ "IT" వద్ద "IT విభాగం" నమోదు చేయండి. ఫలితంగా, వినియోగదారు అర్థం ఏమిటో అస్పష్టంగా ఉంటుంది, అనగా ఈ ఉద్యోగులు ఒకే డిపార్ట్‌మెంట్ ఉద్యోగులా, లేక యూజర్ తనను తాను వివరించాడా మరియు ఇవి 3 విభిన్న విభాగాలు? అంతేకాకుండా, ఈ సందర్భంలో, మేము కొన్ని నివేదికల కోసం డేటాను సరిగ్గా సమూహపరచలేము, ఇక్కడ ప్రతి విభాగం సందర్భంలో ఉద్యోగుల సంఖ్యను చూపించాల్సిన అవసరం ఉండవచ్చు.

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

మూడవ లోపం ఏమిటంటే, స్థానం యొక్క శీర్షిక మారితే ఈ ఫీల్డ్‌లను అప్‌డేట్ చేయడం సంక్లిష్టత, ఉదాహరణకు, మీరు "ప్రోగ్రామర్" స్థానాన్ని "జూనియర్ ప్రోగ్రామర్" గా మార్చవలసి వస్తే. ఈ సందర్భంలో, మేము పట్టికలోని ప్రతి పంక్తికి మార్పులు చేయవలసి ఉంటుంది, దీనిలో స్థానం "ప్రోగ్రామర్" కు సమానంగా ఉంటుంది.

ఈ లోపాలను నివారించడానికి, డేటాబేస్ యొక్క సాధారణీకరణ అని పిలవబడేది ఉపయోగించబడుతుంది-దీనిని ఉప పట్టికలు, సూచన పట్టికలుగా విభజించడం. సిద్ధాంతం యొక్క అడవిలోకి వెళ్లి సాధారణ రూపాలు ఏమిటో అధ్యయనం చేయడం అవసరం లేదు, సాధారణీకరణ యొక్క సారాన్ని అర్థం చేసుకోవడానికి ఇది సరిపోతుంది.

2 పట్టికలను "స్థానాలు" మరియు "విభాగాలు" సృష్టిద్దాం, మొదటిదాన్ని స్థానాలు అని పిలుస్తారు మరియు రెండవది వరుసగా విభాగాలు:

టేబుల్ స్థానాలను రూపొందించండి (ID int IDENTITY (1,1) NULL CONSTRAINT PK_Positions ప్రైమరీ కీ, పేరు nvarchar (30) NULL కాదు) టేబుల్ డిపార్ట్‌మెంట్‌లను రూపొందించండి (ID Int IDNTITY (1,1) పేరు పేరు శూన్యం కాదు)
ఇక్కడ మేము కొత్త గుర్తింపు ఎంపికను ఉపయోగించామని గమనించండి, ఇది ID కాలమ్‌లోని డేటా స్వయంచాలకంగా లెక్కించబడుతుంది, 1 నుండి 1 దశతో ప్రారంభమవుతుంది, అనగా. కొత్త రికార్డులను జోడించినప్పుడు, వాటికి వరుసగా 1, 2, 3, మొదలైన విలువలు కేటాయించబడతాయి. ఇటువంటి ఫీల్డ్‌లను సాధారణంగా ఆటో-ఇంక్రిమెంటుగా సూచిస్తారు. ఐడెంటిటీ ప్రాపర్టీ ఉన్న ఒక ఫీల్డ్‌ని మాత్రమే టేబుల్‌లో నిర్వచించవచ్చు, మరియు సాధారణంగా, కానీ అలాంటి ఫీల్డ్ ఆ టేబుల్‌కు ప్రాథమిక కీ.

నోట్లో
వివిధ DBMS లలో, కౌంటర్‌తో ఫీల్డ్‌ల అమలును వారి స్వంత మార్గంలో చేయవచ్చు. ఉదాహరణకు, MySQL లో, అటువంటి ఫీల్డ్ AUTO_INCREMENT ఎంపికను ఉపయోగించి నిర్వచించబడింది. ORACLE మరియు Firebird లో ముందు ఈ ఫంక్షనాలిటీని సీక్వెన్స్ ఉపయోగించి అనుకరించవచ్చు. కానీ నాకు తెలిసినంత వరకు, ORACLE ఇప్పుడు GENERATED AS IDENTITY ఎంపికను జోడించింది.

ఉద్యోగుల పట్టికలోని పొజిషన్ మరియు డిపార్ట్‌మెంట్ ఫీల్డ్‌లలో రికార్డ్ చేయబడిన ప్రస్తుత డేటా ఆధారంగా ఈ టేబుల్స్ ఆటోమేటిక్‌గా నింపండి:

ఉద్యోగుల పట్టికలోని పొజిషన్ ఫీల్డ్ నుండి ప్రత్యేకమైన విలువలతో పొజిషన్స్ టేబుల్ పేరు ఫీల్డ్‌ని పూరించండి INSERT పొజిషన్స్ (పేరు) ఉద్యోగుల నుండి డిస్టింక్ట్ పొజిషన్‌ను ఎంచుకోండి - ఇక్కడ స్థానం శూన్యం - స్థానం పేర్కొనబడని రికార్డులను విస్మరించండి
విభాగాల పట్టిక కోసం అదే చేద్దాం:

ఇన్‌సర్ట్ విభాగాలు (పేరు) ఉద్యోగుల నుండి డిపార్ట్‌మెంట్ విభాగాన్ని ఎంచుకోండి
మేము ఇప్పుడు స్థానాలు మరియు విభాగాల పట్టికలను తెరిస్తే, ID ఫీల్డ్ కోసం సంఖ్యల విలువలను మేము చూస్తాము:

స్థానాల నుండి * ఎంచుకోండి

విభాగాల నుండి * ఎంచుకోండి

ఈ పట్టికలు ఇప్పుడు స్థానాలు మరియు విభాగాలను కేటాయించడానికి సూచన పుస్తకాల పాత్రను పోషిస్తాయి. మేము ఇప్పుడు ఉద్యోగం మరియు డిపార్ట్‌మెంట్ ID లను సూచిస్తాము. ముందుగా, ఐడెంటిఫైయర్ డేటాను నిల్వ చేయడానికి ఉద్యోగుల పట్టికలో కొత్త ఫీల్డ్‌లను సృష్టిద్దాం:

స్థానం ID కోసం ఒక ఫీల్డ్‌ని జోడించండి టేబుల్ ఉద్యోగులు ADD PositionID int - డిపార్ట్‌మెంట్ ID కోసం ఫీల్డ్‌ను జోడించండి ALTER TABLE ఉద్యోగులు ADD డిపార్ట్‌మెంట్ ID int
రిఫరెన్స్ ఫీల్డ్‌ల రకం రిఫరెన్స్‌ల మాదిరిగానే ఉండాలి, ఈ సందర్భంలో అది పూర్ణాంకం.

కామాతో వేరు చేయబడిన ఫీల్డ్‌లను జాబితా చేస్తూ, ఒకే ఆదేశంతో మీరు ఒకేసారి అనేక ఫీల్డ్‌లను టేబుల్‌కి జోడించవచ్చు:

టేబుల్ టేబుల్ ఉద్యోగులను జోడించండి
ఇప్పుడు మేము ఈ ఫీల్డ్‌ల కోసం లింక్‌లను వ్రాస్తాము (రిఫరెన్స్ అడ్డంకులు - ఫోరెయిన్ కీ) తద్వారా డైరెక్టరీలలో కనిపించే ID విలువలలో లేని విలువలను యూజర్ ఈ ఫీల్డ్‌లలో రాయలేరు.

ఇంకా టేబుల్ ఉద్యోగులు FK_Employees_PositionID FOREIGN KEY (PositionID) రిఫరెన్స్ స్థానాలు (ID)
మరియు రెండవ ఫీల్డ్ కోసం మేము అదే చేస్తాము:

ఇంకా టేబుల్ ఉద్యోగులు FK_Employees_DepartmentID FOREIGN KEY (DepartmentID) రిఫరెన్స్ విభాగాలు (ID)
ఇప్పుడు వినియోగదారు ఈ ఫీల్డ్‌లలో సంబంధిత డైరెక్టరీ నుండి ID విలువలను మాత్రమే నమోదు చేయవచ్చు. దీని ప్రకారం, కొత్త డిపార్ట్‌మెంట్ లేదా పొజిషన్‌ను ఉపయోగించడానికి, అతను ముందుగా సంబంధిత డైరెక్టరీకి కొత్త రికార్డును జోడించాల్సి ఉంటుంది. ఎందుకంటే స్థానాలు మరియు విభాగాలు ఇప్పుడు డైరెక్టరీలలో ఒకే కాపీలో నిల్వ చేయబడ్డాయి, తర్వాత పేరు మార్చడానికి, దాన్ని డైరెక్టరీలో మాత్రమే మార్చుకుంటే సరిపోతుంది.

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

ఐడెంటిఫైయర్ (ID) అనేది సాధారణంగా లింక్‌ల కోసం మాత్రమే ఉపయోగించబడే అంతర్గత విలువ మరియు అక్కడ ఏ విలువ నిల్వ చేయబడుతుంది, చాలా సందర్భాలలో, పూర్తిగా ఉదాసీనంగా ఉంటుంది, కాబట్టి ఉత్పన్నమయ్యే సంఖ్యల క్రమంలో రంధ్రాలను వదిలించుకోవడానికి ప్రయత్నించాల్సిన అవసరం లేదు. టేబుల్‌తో పనిచేసే సమయంలో, ఉదాహరణకు, రిఫరెన్స్ బుక్ నుండి రికార్డులను తొలగించిన తర్వాత.

పట్టిక పట్టిక జోడించండి పరిమితి_పేరు ఫోరెయిన్ కీ (ఫీల్డ్ 1, ఫీల్డ్ 2, ...) రిఫరెన్స్ రిఫరెన్స్_టేబుల్ (ఫీల్డ్ 1, ఫీల్డ్ 2, ...)
ఈ సందర్భంలో, "dir_table" పట్టికలో, ప్రాథమిక కీ అనేక ఫీల్డ్‌ల కలయికతో ప్రాతినిధ్యం వహిస్తుంది (ఫీల్డ్ 1, ఫీల్డ్ 2, ...).

వాస్తవానికి, ఇప్పుడు డైరెక్టరీల నుండి ID విలువలతో POSISID మరియు డిపార్ట్‌మెంట్ ID ఫీల్డ్‌లను అప్‌డేట్ చేద్దాం. ఈ ప్రయోజనం కోసం DML UPDATE ఆదేశాన్ని ఉపయోగిద్దాం:

అప్‌డేట్ ఇ సెట్ సెట్ఐసిడి = (పేరు = ఇ.పొజిషన్‌ల నుండి ఐడిని ఎంచుకోండి
ప్రశ్నను అమలు చేయడం ద్వారా ఏమి జరిగిందో చూద్దాం:

ఉద్యోగుల నుండి ఎంచుకోండి *

అంతే, PositionID మరియు DepartmentID ఫీల్డ్‌లు సంబంధిత స్థానాలు మరియు విభాగాలతో ఐడెంటిఫైయర్‌లతో నిండి ఉంటాయి, ఉద్యోగుల పట్టికలో స్థానం మరియు డిపార్ట్‌మెంట్ ఫీల్డ్‌లు అవసరం లేదు, మీరు ఈ ఫీల్డ్‌లను తొలగించవచ్చు:

టేబుల్ ఉద్యోగుల డ్రాప్ కాలమ్ స్థానం, విభాగం
ఇప్పుడు పట్టిక కింది ఫారమ్‌ను పొందింది:

ఉద్యోగుల నుండి ఎంచుకోండి *

ID	పేరు	పుట్టినరోజు	ఇమెయిల్	స్థానం ID	డిపార్ట్‌మెంట్ ID
1000	ఇవనోవ్ I.I.	శూన్య	శూన్య	2	1
1001	పెట్రోవ్ పి.పి.	శూన్య	శూన్య	3	3
1002	సిడోరోవ్ S.S.	శూన్య	శూన్య	1	2
1003	ఆండ్రీవ్ A.A.	శూన్య	శూన్య	4	3

ఆ. ఫలితంగా, మేము అనవసరమైన సమాచార నిల్వను వదిలించుకున్నాము. ఇప్పుడు, పొజిషన్ మరియు డిపార్ట్‌మెంట్ నంబర్‌ల ఆధారంగా, రిఫరెన్స్ టేబుల్స్‌లోని విలువలను ఉపయోగించి మేము ప్రత్యేకంగా వారి పేర్లను గుర్తించగలము:

D

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

పట్టిక తనను తాను సూచించగలదని కూడా గమనించాలి, అనగా. మీరు పునరావృత లింక్‌ను సృష్టించవచ్చు. ఉదాహరణకు, ఉద్యోగులతో మా టేబుల్‌కు మరొక మేనేజర్ ఐడి ఫీల్డ్‌ని చేర్చుదాం, ఈ ఉద్యోగి ఎవరికి అధీనంలో ఉన్నారో అది సూచిస్తుంది. ఒక ఫీల్డ్‌ను సృష్టిద్దాం:

ఆల్టర్ టేబుల్ ఉద్యోగులు మేనేజర్ ఐడిని జోడించండి
ఈ ఫీల్డ్‌లో NULL అనుమతించబడుతుంది, ఉదాహరణకు, ఉద్యోగి పైన ఉన్నతాధికారులు లేనట్లయితే ఫీల్డ్ ఖాళీగా ఉంటుంది.

ఇప్పుడు ఉద్యోగుల పట్టికలో ఒక ఫారెయిన్ కీని సృష్టిద్దాం:

ఇంకా టేబుల్ ఉద్యోగులు FK_Employees_ManagerID FOREIGN KEY (ManagerID) రిఫరెన్స్ ఉద్యోగుల (ID) ని జోడిస్తారు
ఇప్పుడు ఒక రేఖాచిత్రాన్ని రూపొందిద్దాం మరియు మా పట్టికల మధ్య సంబంధాలు ఎలా ఉన్నాయో చూద్దాం:

తత్ఫలితంగా, మేము ఈ క్రింది చిత్రాన్ని చూడాలి (ఉద్యోగుల పట్టిక స్థానాలు మరియు డిపెర్‌మెంట్‌ల పట్టికలతో ముడిపడి ఉంది, మరియు అది కూడా సూచిస్తుంది):

చివరగా, రిఫరెన్స్ టేబుల్‌లో పేర్కొన్న రికార్డ్‌ను తొలగించేటప్పుడు లేదా అప్‌డేట్ చేసేటప్పుడు ఎలా ప్రవర్తించాలో సూచించే డిలీట్ క్యాస్కేడ్ మరియు అప్‌డేట్ క్యాస్కేడ్‌పై రిఫరెన్స్ కీలు చేర్చబడతాయని పేర్కొనడం విలువ. ఈ ఐచ్ఛికాలు పేర్కొనబడకపోతే, మరొక పట్టిక నుండి లింకులు ఉన్న రికార్డ్ కోసం మేము రిఫరెన్స్ టేబుల్‌లోని ID ని మార్చలేము, రిఫర్ చేసే అన్ని పంక్తులను తొలగించే వరకు మేము అలాంటి రికార్డును రిఫరెన్స్ నుండి తొలగించలేము. ఈ రికార్డుకు, లేదా, మేము ఈ లైన్‌లలోని లింక్‌లను వేరే విలువకు అప్‌డేట్ చేస్తాము.

ఉదాహరణకు, FK_Employees_DepartmentID కోసం ON DELETE CASCADE ఎంపికతో పట్టికను పునreateసృష్టి చేద్దాం:

టేబుల్ ఉద్యోగులను డ్రాప్ చేయండి Table ఉద్యోగులు (ID int NULL, పేరు nvarchar (30), పుట్టినరోజు తేదీ, ఇమెయిల్ nvarchar (30), POSIDID int, DepartmentID ID int, ManagerID int, CONSTRAINT PK_Employees ప్రైమరీ కీ (ID), CONSTRAINT FINT ) రిఫరెన్స్ డిపార్ట్‌మెంట్‌లు (ID) తొలగింపు క్యాస్‌కేడ్‌పై, FK_Employees_PositionID FOREIGN KEY (పొజిషన్‌ఐడి) రిఫరెన్స్ స్థానాలు (ID), CONSTRAINT FK_Employees_ManagerID FOEIGN (I) వ్యక్తి , "19550219", 2,1, NULL), (1001, N "పెట్రోవ్ PP", "19831203", 3,3,1003), (1002, N "సిడోరోవ్ SS", "19760607", 1,2,1000 ), (1003, N "ఆండ్రీవ్ AA", "19820417", 4,3,1000)
విభాగాల పట్టిక నుండి ID 3 తో ​​డిపార్ట్‌మెంట్‌ను తొలగిద్దాం:

ID = 3 ఉన్న విభాగాలను తొలగించండి
ఉద్యోగుల పట్టికలోని డేటాను చూద్దాం:

ఉద్యోగుల నుండి ఎంచుకోండి *

ID	పేరు	పుట్టినరోజు	ఇమెయిల్	స్థానం ID	డిపార్ట్‌మెంట్ ID	మేనేజర్ ఐడి
1000	ఇవనోవ్ I.I.	1955-02-19	శూన్య	2	1	శూన్య
1002	సిడోరోవ్ S.S.	1976-06-07	శూన్య	1	2	1000

మీరు గమనిస్తే, డిపార్ట్‌మెంట్ 3 కోసం డేటా కూడా ఉద్యోగుల పట్టిక నుండి తొలగించబడింది.

ON అప్‌డేట్ క్యాస్కేడ్ ఎంపిక కూడా అదేవిధంగా ప్రవర్తిస్తుంది, కానీ లుకప్‌లో ID విలువ అప్‌డేట్ అయినప్పుడు ఇది పనిచేస్తుంది. ఉదాహరణకు, మేము జాబ్ డైరెక్టరీలో పొజిషన్ ఐడిని మార్చినట్లయితే, ఎంప్లాయీస్ టేబుల్‌లోని డిపార్ట్‌మెంట్ ఐడి డైరెక్టరీలో మేము పేర్కొన్న కొత్త ఐడి విలువకు అప్‌డేట్ చేయబడుతుంది. కానీ ఈ సందర్భంలో దీన్ని ప్రదర్శించడం సాధ్యం కాదు, ఎందుకంటే విభాగాల పట్టికలోని ID కాలమ్‌లో IDENTITY ఎంపిక ఉంది, ఇది కింది అభ్యర్థనను అమలు చేయడానికి మాకు అనుమతించదు (డిపార్ట్‌మెంట్ ID 3 నుండి 30 వరకు మార్చండి):

UPDATE విభాగాలు SET ID = 30 ఎక్కడ ID = 3
ప్రధాన విషయం ఏమిటంటే డెలిట్ క్యాస్కేడ్ మరియు అప్‌డేట్ క్యాస్కేడ్‌లో ఈ 2 ఎంపికల సారాన్ని అర్థం చేసుకోవడం. నేను ఈ ఎంపికలను చాలా అరుదుగా ఉపయోగిస్తాను మరియు వాటిని రిఫరెన్సింగ్ పరిమితిలో ఉపయోగించే ముందు మీరు జాగ్రత్తగా ఆలోచించాలని నేను సిఫార్సు చేస్తున్నాను. మీరు అనుకోకుండా లుకప్ టేబుల్ నుండి రికార్డును తొలగిస్తే, ఇది పెద్ద సమస్యలకు దారితీస్తుంది మరియు చైన్ రియాక్షన్‌ను సృష్టిస్తుంది.

డిపార్ట్మెంట్ 3 ని పునరుద్ధరిద్దాం:

ఐడెంటిటీ విలువను జోడించడానికి / మార్చడానికి అనుమతి ఇవ్వండి.
TRUNCATE TABLE ఆదేశాన్ని ఉపయోగించి ఉద్యోగుల పట్టికను పూర్తిగా శుభ్రం చేద్దాం:

టేబుల్ ఉద్యోగులను బదిలీ చేయండి
మళ్లీ, మునుపటి INSERT ఆదేశాన్ని ఉపయోగించి డేటాను రీలోడ్ చేయండి:

INSERT ఉద్యోగులు (ID, పేరు, పుట్టినరోజు, పొజిషన్ ID, డిపార్ట్‌మెంట్ ID, మేనేజర్ ID) విలువలు (1000, N "ఇవనోవ్ I.I.", "19550219", 2,1, NULL), (1001, N "పెట్రోవ్ P.P.", "19831203", 3 , 3,1003), (1002, N "సిడోరోవ్ SS", "19760607", 1,2,1000), (1003, N "ఆండ్రీవ్ AA", "19820417", 4,3,1000)

సంగ్రహంగా చూద్దాం

ప్రస్తుతానికి, మా జ్ఞానానికి మరికొన్ని DDL ఆదేశాలు జోడించబడ్డాయి:

• ఫీల్డ్‌కు గుర్తింపు ఆస్తిని జోడించడం - పట్టిక కోసం ఈ ఫీల్డ్‌ను ఆటోమేటిక్‌గా నింపడానికి (కౌంటర్ ఫీల్డ్) చేయడానికి మిమ్మల్ని అనుమతిస్తుంది;
• పట్టికటేబుల్_పేరు జోడించు list_of_fields_with_characteristics - పట్టికలో కొత్త ఫీల్డ్‌లను జోడించడానికి మిమ్మల్ని అనుమతిస్తుంది;
• పట్టికటేబుల్_పేరు డ్రాప్ కాలమ్ list_of_field - పట్టిక నుండి ఫీల్డ్‌లను తొలగించడానికి మిమ్మల్ని అనుమతిస్తుంది;
• పట్టికటేబుల్_పేరు నిర్మాణాన్ని జోడించండినిర్బంధం_పేరు విదేశీ కీ(ఖాళీలు) ప్రస్తావనలురిఫరెన్స్_టేబుల్ (ఫీల్డ్‌లు) - టేబుల్ మరియు రిఫరెన్స్ టేబుల్ మధ్య సంబంధాన్ని నిర్వచించడానికి మిమ్మల్ని అనుమతిస్తుంది.

ఇతర పరిమితులు - ప్రత్యేకమైనది, అపజయం, తనిఖీ చేయండి

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

అప్‌డేట్ ఎంప్లాయీస్ సెట్ ఇమెయిల్ = " [ఇమెయిల్ రక్షించబడింది]"ఎక్కడ ID = 1000 అప్‌డేట్ ఉద్యోగులు SET ఇమెయిల్ =" [ఇమెయిల్ రక్షించబడింది]"ఎక్కడ ID = 1001 అప్‌డేట్ ఉద్యోగులు SET ఇమెయిల్ =" [ఇమెయిల్ రక్షించబడింది]"ఎక్కడ ID = 1002 అప్‌డేట్ ఉద్యోగులు SET ఇమెయిల్ =" [ఇమెయిల్ రక్షించబడింది]"ఎక్కడ ID = 1003
మరియు ఇప్పుడు మీరు ఈ ఫీల్డ్‌పై ఒక ప్రత్యేకత-పరిమితిని విధించవచ్చు:

ఆల్టర్ టేబుల్ ఉద్యోగులు CONSTRAINT UQ_Employees_Email UNIQUE (ఇమెయిల్) జోడించండి
ఇప్పుడు వినియోగదారు అనేక మంది ఉద్యోగుల కోసం ఒకే ఇ-మెయిల్‌ని నమోదు చేయలేరు.

విశిష్టత పరిమితి సాధారణంగా ఈ క్రింది విధంగా పేరు పెట్టబడుతుంది - ముందుగా "UQ_" ఉపసర్గ వస్తుంది, తరువాత పట్టిక పేరు వస్తుంది, మరియు అండర్‌స్కోర్ తర్వాత ఈ అడ్డంకి వర్తింపజేసిన ఫీల్డ్ పేరు ఉంటుంది.

దీని ప్రకారం, పట్టిక వరుసల సందర్భంలో ఫీల్డ్‌ల కలయిక ప్రత్యేకంగా ఉంటే, కామాలతో వేరు చేయబడిన వాటిని మేము జాబితా చేస్తాము:

టేబుల్ టేబుల్_పేరు జోడించండి
ఫీల్డ్‌కు ఒక డిఫాల్ట్ అడ్డంకిని జోడించడం ద్వారా, ఇన్‌సర్ట్ చేసేటప్పుడు ప్రత్యామ్నాయంగా ఉండే డిఫాల్ట్ విలువను మనం సెట్ చేయవచ్చు కొత్త ప్రవేశం INSERT ఆదేశంలోని ఫీల్డ్‌ల జాబితాలో ఈ ఫీల్డ్ జాబితా చేయబడదు. పట్టికను సృష్టించేటప్పుడు ఈ పరిమితిని నేరుగా సెట్ చేయవచ్చు.

ఉద్యోగుల పట్టికలో కొత్త అపాయింట్‌మెంట్ తేదీ ఫీల్డ్‌ని జోడించి దానికి HireDate అని పేరు పెట్టండి మరియు ఈ ఫీల్డ్ డిఫాల్ట్ విలువ ప్రస్తుత తేదీ అని చెప్పండి:

ఇంకా టేబుల్ ఉద్యోగులు నియామక తేదీని జోడించండి శూన్యమైన తేదీ కాదు ()
లేదా HireDate కాలమ్ ఇప్పటికే ఉన్నట్లయితే, కింది వాక్యనిర్మాణాన్ని ఉపయోగించవచ్చు:

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

పట్టికలోని ఉద్యోగులందరూ నియమిత DF_Employees_HireDate నియామక తేదీకి డిఫాల్ట్ సిస్టమ్ () ని జోడిస్తారు
ఈ కాలమ్ ఇంతకు ముందు లేనందున, ప్రతి రికార్డుకు జోడించబడినప్పుడు, ప్రస్తుత తేదీ విలువ HireDate ఫీల్డ్‌లోకి చేర్చబడుతుంది.

కొత్త రికార్డ్‌ని జోడించినప్పుడు, ప్రస్తుత తేదీ కూడా ఆటోమేటిక్‌గా చేర్చబడుతుంది, వాస్తవానికి, మేము దానిని స్పష్టంగా సెట్ చేయకపోతే, అనగా. నిలువు వరుసల జాబితాలో పేర్కొనబడదు. జోడించిన విలువల జాబితాలో HireDate ఫీల్డ్‌ని పేర్కొనకుండా దీనిని ఉదాహరణతో చూపిద్దాం:

INSERT ఉద్యోగులు (ID, పేరు, ఇమెయిల్) విలువలు (1004, N "సెర్జీవ్ S.S.", " [ఇమెయిల్ రక్షించబడింది]")
ఏమి జరిగిందో చూద్దాం:

ఉద్యోగుల నుండి ఎంచుకోండి *

ID	పేరు	పుట్టినరోజు	ఇమెయిల్	స్థానం ID	డిపార్ట్‌మెంట్ ID	మేనేజర్ ఐడి	నియమించుకున తేది
1000	ఇవనోవ్ I.I.	1955-02-19	[ఇమెయిల్ రక్షించబడింది]	2	1	శూన్య	2015-04-08
1001	పెట్రోవ్ పి.పి.	1983-12-03	[ఇమెయిల్ రక్షించబడింది]	3	4	1003	2015-04-08
1002	సిడోరోవ్ S.S.	1976-06-07	[ఇమెయిల్ రక్షించబడింది]	1	2	1000	2015-04-08
1003	ఆండ్రీవ్ A.A.	1982-04-17	[ఇమెయిల్ రక్షించబడింది]	4	3	1000	2015-04-08
1004	సెర్జీవ్ S.S.	శూన్య	[ఇమెయిల్ రక్షించబడింది]	శూన్య	శూన్య	శూన్య	2015-04-08

ఫీల్డ్‌లోకి చొప్పించిన విలువలను తనిఖీ చేయడానికి అవసరమైనప్పుడు CHECK పరిమితి ఉపయోగించబడుతుంది. ఉదాహరణకు, మా ఉద్యోగుల గుర్తింపు (ID) అయిన పర్సనల్ నంబర్ ఫీల్డ్‌పై ఈ పరిమితిని విధిద్దాం. ఈ పరిమితిని ఉపయోగించి, సిబ్బంది సంఖ్యలకు 1000 మరియు 1999 మధ్య విలువ ఉండాలి అని చెప్పండి:

ఇంకా టేబుల్ ఉద్యోగులు CK_Employees_ID తనిఖీని జోడించండి (1000 మరియు 1999 మధ్య ID)
పరిమితి సాధారణంగా అదే పేరు పెట్టబడుతుంది, ముందుగా "CK_" ఉపసర్గ వస్తుంది, తర్వాత పట్టిక పేరు మరియు పరిమితి విధించబడిన ఫీల్డ్ పేరు.

పరిమితి పనిచేస్తుందో లేదో తనిఖీ చేయడానికి చెల్లని ఎంట్రీని చొప్పించడానికి ప్రయత్నిద్దాం (మేము సంబంధిత దోషాన్ని పొందాలి):

ఇన్సర్ట్ ఉద్యోగులు (ID, ఇమెయిల్) విలువలు (2000, " [ఇమెయిల్ రక్షించబడింది]")
ఇప్పుడు చొప్పించిన విలువను 1500 కి మార్చండి మరియు రికార్డు చొప్పించబడిందని నిర్ధారించుకోండి:

ఇన్సర్ట్ ఉద్యోగులు (ID, ఇమెయిల్) విలువలు (1500, " [ఇమెయిల్ రక్షించబడింది]")
పేరును పేర్కొనకుండా మీరు ప్రత్యేకమైన మరియు చెక్ అడ్డంకులను కూడా సృష్టించవచ్చు:

ఇంకా టేబుల్ ఉద్యోగులు ప్రత్యేకతను జోడిస్తారు (ఇమెయిల్) టేబుల్ ఉద్యోగులు చెక్ జోడించండి (ID 1000 మరియు 1999 మధ్య)
అయితే ఇది మంచి పద్దతి కాదు మరియు కనుక నిర్భంధం పేరును స్పష్టంగా పేర్కొనడం మంచిది తర్వాత దాన్ని గుర్తించడానికి, ఇది మరింత కష్టతరం అవుతుంది, మీరు ఆ వస్తువును తెరిచి, దానికి బాధ్యత ఏమిటో చూడాలి.

మంచి పేరుతో, పరిమితి గురించి చాలా సమాచారాన్ని దాని పేరు ద్వారా నేరుగా కనుగొనవచ్చు.

మరియు, తదనుగుణంగా, పట్టికను సృష్టించినప్పుడు ఈ పరిమితులన్నింటినీ వెంటనే సృష్టించవచ్చు, అది ఇప్పటికే ఉనికిలో లేకపోతే. పట్టికను తొలగిద్దాం:

టేబుల్ ఉద్యోగులను డ్రాప్ చేయండి
మరియు మేము సృష్టించిన అన్ని ఆంక్షలతో ఒక క్రియేట్ టేబుల్ కమాండ్‌తో పునreateసృష్టిస్తాము:

టేబుల్ ఉద్యోగులను సృష్టించండి (ID పూర్తి కాదు, పేరు nvarchar (30), పుట్టినరోజు తేదీ, ఇమెయిల్ nvarchar (30), POSIDID Int, డిపార్ట్‌మెంట్ ID int, HireDate తేదీ శూన్యమైన తేదీ కాదు () (ID), CONSTRAINT FK_Employees_D విభజన

INSERT ఉద్యోగులు (ID, పేరు, పుట్టినరోజు, ఇమెయిల్, పొజిషన్ ID, డిపార్ట్‌మెంట్ ID) విలువలు (1000, N "ఇవనోవ్ I.I.", "19550219", " [ఇమెయిల్ రక్షించబడింది]", 2,1), (1001, N" పెట్రోవ్ P.P. "," 19831203 "," [ఇమెయిల్ రక్షించబడింది]", 3,3), (1002, N" సిడోరోవ్ S.S. "," 19760607 "," [ఇమెయిల్ రక్షించబడింది]", 1,2), (1003, N" ఆండ్రీవ్ A.A. "," 19820417 "," [ఇమెయిల్ రక్షించబడింది]",4,3)

ప్రాథమిక కీ మరియు ప్రత్యేక అడ్డంకులను సృష్టించేటప్పుడు సృష్టించబడిన సూచికల గురించి కొంచెం

మీరు పైన స్క్రీన్ షాట్‌లో చూడగలిగినట్లుగా, ప్రాథమిక కీ మరియు ఏకైక అడ్డంకులను సృష్టించేటప్పుడు, అదే పేర్లతో సూచికలు (PK_Employees మరియు UQ_Employees_Email) స్వయంచాలకంగా సృష్టించబడతాయి. డిఫాల్ట్‌గా, ప్రాథమిక కీ కోసం సూచిక క్లస్టర్డ్‌గా, మరియు అన్ని ఇతర ఇండెక్స్‌ల కోసం నాన్‌క్లస్టర్డ్‌గా సృష్టించబడుతుంది. అన్ని DBMS క్లస్టర్డ్ ఇండెక్స్ అనే భావనను కలిగి ఉండవని చెప్పాలి. ఒక టేబుల్‌లో ఒక క్లస్టర్డ్ ఇండెక్స్ మాత్రమే ఉంటుంది. క్లస్టర్డ్ - అంటే ఈ సూచిక ద్వారా పట్టిక రికార్డులు క్రమబద్ధీకరించబడతాయి, ఈ సూచిక అన్ని పట్టిక డేటాకు ప్రత్యక్ష ప్రాప్యతను కలిగి ఉందని కూడా మీరు చెప్పవచ్చు. ఇది చెప్పాలంటే, పట్టిక యొక్క ప్రధాన సూచిక. మరింత స్థూలంగా, ఇది పట్టికకు బోల్ట్ చేయబడిన సూచిక. క్లస్టర్డ్ ఇండెక్స్ అనేది మీ ప్రశ్నలను ఆప్టిమైజ్ చేయడంలో సహాయపడే చాలా శక్తివంతమైన సాధనం, ప్రస్తుతానికి దాన్ని గుర్తుంచుకోండి. క్లస్టర్డ్ ఇండెక్స్‌ను ప్రాథమిక కీలో కాకుండా మరొక ఇండెక్స్ కోసం ఉపయోగించమని చెప్పాలనుకుంటే, ప్రైమరీ కీని క్రియేట్ చేసేటప్పుడు, మేము NONCLUSTERED ఆప్షన్‌ని పేర్కొనాలి:

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

ఆల్టర్ టేబుల్ ఉద్యోగులు డ్రాప్ కాంట్రాస్ట్ PK_ ఎంప్లాయిస్ ఆల్టర్ టేబుల్ ఉద్యోగులు డ్రాప్ కాంట్రాక్ట్ UQ_Employees_Email
ఇప్పుడు వాటిని క్లస్టర్డ్ మరియు నాన్‌క్లస్టర్డ్ ఎంపికలతో సృష్టిద్దాం:

ఆల్టర్ టేబుల్ ఉద్యోగులు అనుబంధ PK_Employees ప్రైమరీ కీని జోడించరు (ID) ఇతర టేబుల్ ఉద్యోగులు జోడిస్తారు UQ_Employees_Email ప్రత్యేక క్లస్టర్ (ఇమెయిల్)
ఇప్పుడు, ఉద్యోగుల పట్టిక నుండి పొందిన తర్వాత, క్లస్టర్డ్ UQ_Employees_Email సూచిక ద్వారా రికార్డులు క్రమబద్ధీకరించబడినట్లు మనం చూడవచ్చు:

ఉద్యోగుల నుండి ఎంచుకోండి *

ID	పేరు	పుట్టినరోజు	ఇమెయిల్	స్థానం ID	డిపార్ట్‌మెంట్ ID	నియమించుకున తేది
1003	ఆండ్రీవ్ A.A.	1982-04-17	[ఇమెయిల్ రక్షించబడింది]	4	3	2015-04-08
1000	ఇవనోవ్ I.I.	1955-02-19	[ఇమెయిల్ రక్షించబడింది]	2	1	2015-04-08
1001	పెట్రోవ్ పి.పి.	1983-12-03	[ఇమెయిల్ రక్షించబడింది]	3	3	2015-04-08
1002	సిడోరోవ్ S.S.	1976-06-07	[ఇమెయిల్ రక్షించబడింది]	1	2	2015-04-08

దీనికి ముందు, PK_Employees ఇండెక్స్ క్లస్టర్డ్ ఇండెక్స్‌గా ఉన్నప్పుడు, రికార్డులు డిఫాల్ట్‌గా ID ద్వారా క్రమబద్ధీకరించబడ్డాయి.

కానీ ఈ సందర్భంలో, ఇది క్లస్టర్డ్ ఇండెక్స్ యొక్క సారాన్ని చూపించే ఒక ఉదాహరణ మాత్రమే చాలా మటుకు, ID ఫీల్డ్ ద్వారా ఎంప్లాయీస్ టేబుల్‌కు ప్రశ్నలు ఇవ్వబడతాయి మరియు కొన్ని సందర్భాల్లో, ఇది రిఫరెన్స్ పుస్తకంగా పనిచేస్తుంది.

డైరెక్టరీల కోసం, క్లస్టర్డ్ ఇండెక్స్ ప్రాథమిక కీపై నిర్మించడం సాధారణంగా మంచిది అభ్యర్థనలలో, మేము తరచుగా డైరెక్టరీ ఐడెంటిఫైయర్‌ను పొందడానికి సూచిస్తాము, ఉదాహరణకు, పేరు (స్థానం, విభాగం). క్లస్టర్డ్ ఇండెక్స్ టేబుల్ యొక్క అడ్డు వరుసలకు నేరుగా యాక్సెస్ చేయగలదని మరియు అదనపు ఓవర్ హెడ్ లేకుండా ఏ కాలమ్ విలువను అయినా పొందవచ్చని నేను పైన వ్రాసిన వాటిని ఇక్కడ గుర్తుచేసుకుందాం.

చాలా తరచుగా నమూనా చేయబడిన ఫీల్డ్‌లకు క్లస్టర్డ్ ఇండెక్స్‌ను వర్తింపజేయడం ప్రయోజనకరంగా ఉంటుంది.

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

సంగ్రహంగా చూద్దాం

ఈ దశలో, అన్ని రకాల అడ్డంకులు, వాటి సరళమైన రూపంలో, "ALTER TABLE table_name ADD CONSTRAINT constraint_name ..." అనే కమాండ్ ద్వారా సృష్టించబడ్డాయి:

• ప్రాథమిక కీ- ప్రాథమిక కీ;
• విదేశీ కీ- లింక్‌లను సెటప్ చేయడం మరియు డేటా రిఫరెన్షియల్ సమగ్రతను నియంత్రించడం;
• ఏకైక- ప్రత్యేకతను సృష్టించడానికి మిమ్మల్ని అనుమతిస్తుంది;
• తనిఖీ- నమోదు చేసిన డేటా యొక్క ఖచ్చితత్వాన్ని అనుమతిస్తుంది;
• వైఫల్యం- డిఫాల్ట్ విలువను సెట్ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది;
• ఆదేశాన్ని ఉపయోగించి అన్ని ఆంక్షలను తొలగించవచ్చని కూడా గమనించాలి పట్టికటేబుల్_పేరు డ్రాప్ నిర్మాణంనిర్బంధం_పేరు ".

మేము సూచికల అంశంపై పాక్షికంగా స్పృశించాము మరియు క్లస్టర్ భావనను విశ్లేషించాము ( క్లస్టర్ చేయబడింది) మరియు నాన్ క్లస్టర్డ్ ( అన్‌క్లస్టర్డ్) సూచిక.

స్వతంత్ర సూచికలను సృష్టించండి

ఇక్కడ స్వయంప్రతిపత్తి అనేది ప్రాథమిక కీ లేదా ప్రత్యేక పరిమితి కోసం సృష్టించబడని సూచికలను సూచిస్తుంది.

ఫీల్డ్ లేదా ఫీల్డ్‌ల ద్వారా సూచికలను కింది ఆదేశంతో సృష్టించవచ్చు:

INDEX IDX_Employees_Name ఉద్యోగులపై పేరు సృష్టించండి (పేరు)
అలాగే ఇక్కడ మీరు క్లస్టర్డ్, నాన్‌క్లస్టర్డ్, ప్రత్యేకమైన ఎంపికలను పేర్కొనవచ్చు మరియు మీరు ప్రతి వ్యక్తి ASC ఫీల్డ్ (డిఫాల్ట్‌గా) లేదా DESC కోసం సార్టింగ్ దిశను కూడా పేర్కొనవచ్చు:

ఏకైక NONCLUSTED INDEX UQ_Employees_EmailDesc ఆన్ ఉద్యోగులను సృష్టించండి (ఇమెయిల్ DESC)
నాన్‌క్లస్టర్డ్ ఇండెక్స్‌ను క్రియేట్ చేస్తున్నప్పుడు, నాన్‌క్లస్టర్డ్ ఆప్షన్‌ను విడుదల చేయవచ్చు ఎందుకంటే ఇది డిఫాల్ట్ మరియు కమాండ్‌లోని క్లస్టర్డ్ లేదా నాన్‌క్లస్టర్డ్ ఆప్షన్ యొక్క స్థానాన్ని సూచించడానికి ఇక్కడ చూపబడింది.

కింది ఆదేశంతో మీరు సూచికను తొలగించవచ్చు:

ఉద్యోగులపై INDEX IDX_Employees_NEP డ్రాప్ చేయండి
సాధారణ సూచికలు, అడ్డంకులు వంటివి, క్రియేట్ టేబుల్ కమాండ్ సందర్భంలో సృష్టించబడతాయి.

ఉదాహరణకు, పట్టికను మళ్లీ వదులుదాం:

టేబుల్ ఉద్యోగులను డ్రాప్ చేయండి
మరియు సృష్టించబడిన అన్ని అడ్డంకులు మరియు ఇండెక్స్‌లతో ఒక క్రియేట్ టేబుల్ కమాండ్‌తో దీన్ని పునreateసృష్టి చేద్దాం:

టేబుల్ ఉద్యోగులను సృష్టించండి (ID పూర్తి కాదు, పేరు nvarchar (30), పుట్టినరోజు తేదీ, ఇమెయిల్ nvarchar (30), POSIDID Int, డిపార్ట్‌మెంట్ ID int, HireDate తేదీ NULL కాంట్రాక్ట్ DF_Employees_HireDY డిఫాల్ట్ ఇంటెయిమ్‌టైమ్ టైమ్ () నిరోధ FK_Employees_DepartmentID విదేశీ KEY (DepartmentID) సూచనలు విభాగాలు (ID), నిరోధ FK_Employees_PositionID విదేశీ KEY (PositionID) సూచనలు పదవులు (ID), నిరోధ FK_Employees_ManagerID విదేశీ KEY (ఇమెయిల్) చెక్ (1000 మరియు 1999 మధ్య ID), INDEX IDX_Employees_Name (పేరు))
చివరగా, మా ఉద్యోగులను పట్టికలో చేర్చండి:

INSERT ఉద్యోగులు (ID, పేరు, పుట్టినరోజు, ఇమెయిల్, పొజిషన్ ID, DepartmentID, ManagerID) విలువలు (1000, N "ఇవనోవ్ I.I.", "19550219", " [ఇమెయిల్ రక్షించబడింది]", 2,1, NULL), (1001, N" పెట్రోవ్ P.P. "," 19831203 "," [ఇమెయిల్ రక్షించబడింది]", 3,3,1003), (1002, N" సిడోరోవ్ S.S. "," 19760607 "," [ఇమెయిల్ రక్షించబడింది]", 1,2,1000), (1003, N" ఆండ్రీవ్ A.A. "," 19820417 "," [ఇమెయిల్ రక్షించబడింది]",4,3,1000)
అదనంగా, మీరు విలువలను INCLUDE లో పేర్కొనడం ద్వారా నాన్‌క్లస్టర్డ్ ఇండెక్స్‌లో చేర్చవచ్చు. ఆ. ఈ సందర్భంలో, INCLUDE ఇండెక్స్ కొంతవరకు క్లస్టర్డ్ ఇండెక్స్‌ని పోలి ఉంటుంది, ఇప్పుడు మాత్రమే ఇండెక్స్ టేబుల్‌కు బోల్ట్ చేయబడదు, కానీ అవసరమైన విలువలు ఇండెక్స్‌కు బోల్ట్ చేయబడతాయి. దీని ప్రకారం, అటువంటి సూచికలు ఎంచుకున్న ప్రశ్నల (SELECT) పనితీరును బాగా మెరుగుపరుస్తాయి, జాబితా చేయబడిన అన్ని ఫీల్డ్‌లు సూచికలో ఉన్నట్లయితే, అప్పుడు పట్టికను యాక్సెస్ చేయడం అవసరం కాకపోవచ్చు. కానీ ఇది సహజంగా ఇండెక్స్ పరిమాణాన్ని పెంచుతుంది జాబితా చేయబడిన ఫీల్డ్‌ల విలువలు ఇండెక్స్‌లో నకిలీ చేయబడతాయి.

MSDN నుండి సారాంశం.సూచికలను సృష్టించడానికి సాధారణ ఆదేశ సింటాక్స్

సృష్టించు [ప్రత్యేకమైనది] [క్లస్టర్డ్ | NONCLUSTERED] INDEX index_name ఆన్‌లో ఉంది