SQL పరీక్ష ప్రాక్టీస్

అసలు పరీక్ష సాధారణంగా ఎలా ఉంటుంది

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

• HackerRank SQL నైపుణ్య పరీక్షలు. HackerRank తన SQL (Basic) నైపుణ్య పరీక్షలో 30 నిమిషాల్లో 2 ప్రశ్నలు ఉంటాయని, సాధారణ queries వంటి అంశాలను కవర్ చేస్తుందని పేర్కొంటుంది (HackerRank). అలాగే, SQL (Intermediate) పరీక్షలో 35 నిమిషాల్లో 2 ప్రశ్నలు ఉంటాయని, క్లిష్టమైన joins వంటి అంశాలను కవర్ చేస్తుందని పేర్కొంటుంది (HackerRank). సొంత HackerRank పరీక్షలను రూపొందించే ఉద్యోగదాతలు database ప్రశ్నలను జోడించవచ్చు, అలాగే అభ్యర్థులు ఏ databases ఉపయోగించవచ్చో ఎంచుకోవచ్చు (HackerRank support).
• Query రాసే పని. TestGorilla, తన SQLite coding test‌లో 30 నిమిషాల పాటు మధ్యస్థ క్లిష్టత కలిగిన database‌పై వాస్తవిక పరిస్థితికి query రాయాల్సి ఉంటుందని వివరిస్తుంది. ఇందులో joins, filtering, సాధారణ లెక్కలు, sorting, rounding, అనవసరమైన entries‌ను మినహాయించడం వంటి అంశాలు ఉంటాయి (TestGorilla).
• సంక్షిప్త జ్ఞాన పరీక్ష. TestGorilla తన MySQL పరీక్షలో 101 ప్రశ్నల బ్యాంక్ నుంచి తీసుకున్న 10 నిమిషాల్లో 15 ప్రశ్నలు ఉంటాయని పేర్కొంటుంది (TestGorilla).

SQL పరీక్షల్లో సాధారణంగా కనిపించే అంశాలు:

• Filtering మరియు sorting: SELECT, WHERE, ORDER BY, అలాగే AND, OR, IN మరియు BETWEEN ఉపయోగించే షరతులు.
• Joins: inner, left joins, అలాగే సరిపోలిక లేని rows‌కు ఏమవుతుందో.
• Grouping: COUNT, SUM, AVG, MIN మరియు MAX‌తో GROUP BY, అలాగే groups‌ను filter చేయడానికి HAVING.
• NULLలు: comparisons, counts మరియు averages‌లో ఖాళీ విలువలు ఎలా పనిచేస్తాయో.
• Subqueries: IN, EXISTS లేదా ఒకే విలువతో, మరో query లోపల ఉండే query.
• సాధారణ భాషలో ఇచ్చిన అభ్యర్థన ఆధారంగా query రాయడం, ఇందులో ఆశించిన rows‌నే ఖచ్చితంగా చూపిస్తుందా అనే దానిపై తరచుగా మార్కులు ఇస్తారు.

మా మాక్ పరీక్షల్లో ఉండేవి. ప్రతి పూర్తి మాక్ పరీక్షలో నాలుగు విభాగాలుగా 45 నిమిషాల్లో 18 ప్రశ్నలు ఉంటాయి: SQL భావనలు (5), query ఏ ఫలితాన్ని ఇస్తుందో (6), queryని సరిచేయడం (4), సరైన queryని ఎంచుకోవడం (3). మీరు వెనక్కి వెళ్లి ప్రశ్నలకు గుర్తు పెట్టుకోవచ్చు. మేము వివిధ databases‌లో ఉపయోగించగల standard SQL‌ను ఉపయోగిస్తాం. అందువల్ల PostgreSQL, MySQL, SQL Server, SQLite, ఇంకా చాలా ఇతర databases‌లో queries ఒకే అర్థాన్ని ఇస్తాయి. మా మాక్ పరీక్షలు queries‌ను చదవడం, వాటి ఫలితాలను దశలవారీగా తెలుసుకోవడం, సరైన queries‌ను ఎంచుకోవడం సాధన చేయిస్తాయి; మీరు రాసిన queries‌ను అమలు చేయవు. చాలా నిజమైన SQL పరీక్షల్లో ఆశించిన ఫలితాలతో పోల్చి తనిఖీ చేసే queryని రాయమంటారు. అందుకు అవసరమైన చదివే, ఫలితాలను దశలవారీగా తెలుసుకునే నైపుణ్యాలను పెంచుకోవడానికి మా మాక్ పరీక్షలను ఉపయోగించండి. అలాగే SQLite వంటి ఉచిత database‌లో మీరే queries రాయడం కూడా సాధన చేయండి.

వివరణాత్మక ఉదాహరణలతో ప్రశ్నల రకాలు

ప్రతి విభాగానికి ఒక ఉదాహరణ, చాలామంది చేసే పొరపాటుతో సహా.

1. SQL భావనలు. COUNT()కు, COUNT(email)కు మధ్య తేడా ఏమిటి? COUNT() ప్రతి rowను లెక్కిస్తుంది; COUNT(email)లో email NULL కాని rowsను మాత్రమే లెక్కిస్తుంది. పొరపాటు: ప్రతి countలోనూ ప్రతి row చేరుతుందని అనుకోవడం. చాలా aggregate functions NULLలను దాటవేస్తాయి.

2. query ఏమి ఇస్తుంది. scores అనే tableలో 8, 5, NULL, 8 విలువలు ఉన్నాయి. SELECT COUNT(DISTINCT score) ఏమి ఇస్తుంది? వేర్వేరు, NULL కాని విలువలు 8, 5. కాబట్టి సమాధానం 2. పొరపాటు: NULLను ఒక విలువగా లెక్కించడం లేదా పునరావృతమైన 8ను రెండుసార్లు లెక్కించడం. tableను రాసుకుని, query చేసే విధంగా ఒక్కో rowను కొట్టివేయండి.

3. queryను సరిచేయడం. ఒక queryలో WHERE city = 'Austin' OR city = 'Dallas' AND active = 1 ఉంది. ఇది inactive Austin customersను కూడా చూపిస్తోంది. ANDకు OR కంటే ముందుగా ప్రాధాన్యం ఉంటుంది. కాబట్టి ఈ condition అర్థం Austin లేదా active Dallas అని. దీనికి పరిష్కారం brackets: WHERE (city = 'Austin' OR city = 'Dallas') AND active = 1. పొరపాటు: conditionను ఎడమ నుంచి కుడికి చదవడం.

4. సరైన queryని ఎంచుకోవడం. ఇటీవలి ఐదు orders కావాలి. ఏది సరైనది: ORDER BY order_date DESCతో 5 limit పెట్టడమా, లేక ORDER BY order_dateతో 5 limit పెట్టడమా? మొదటిది. DESC లేకపోతే పాతవి ముందు వస్తాయి, కాబట్టి ఐదు అత్యంత పాత orders లభిస్తాయి. పొరపాటు: sort దిశను తనిఖీ చేయకుండా, సరైనదిగా కనిపించే queryని ఎంచుకోవడం. (డేటాబేస్‌లలో limitను LIMIT 5 లేదా FETCH FIRST 5 ROWS ONLY వంటి వేర్వేరు విధాలుగా రాస్తారు. కాబట్టి మీ testలో ఏది ఉపయోగిస్తున్నారో చూడండి.)

5. conditionsతో joins. left join తర్వాత, కుడి table columnపై WHERE condition పెడితే అది తెలియకుండానే inner joinగా మారుతుంది. ఎందుకంటే సరిపోలని rowsలో ఆ column NULLగా ఉంటుంది, condition వాటిని తొలగిస్తుంది. పొరపాటు: ఏ rows మాయమవుతున్నాయో గమనించకపోవడం. "సరిపోలే row లేకపోతే ఆ rowకు ఏమవుతుంది?" అని ప్రశ్నించండి.

ఎలా సిద్ధం కావాలి

1. ముందుగా మీ ఆహ్వానాన్ని చదవండి. మీరు ఏ ప్లాట్‌ఫారమ్‌ను ఉపయోగించాలి, మీకు ఎంత సమయం ఉంది, మీరు queries రాయాలా లేదా multiple choice ప్రశ్నలకు సమాధానం ఇవ్వాలా, అలాగే అది ఏ database మీద నడుస్తుందో తెలుసుకోండి. పరీక్షల రూపాలు చాలా భిన్నంగా ఉంటాయి, కాబట్టి ముందే ఊహించకండి.
2. Query అమలయ్యే క్రమాన్ని తెలుసుకోండి. ముందుగా FROM మరియు JOIN, ఆ తర్వాత WHERE, GROUP BY, HAVING, SELECT, ORDER BY. ఏ దశలో ఏ data అందుబాటులో ఉంటుందో తెలిసినప్పుడు, "ఇది ఎందుకు తప్పు?" అనే చాలా ప్రశ్నలు సులభంగా అర్థమవుతాయి.
3. చిన్న tables‌ను చేతితో అనుసరించండి. మూడు లేదా నాలుగు rows రాసి, ప్రతి clause‌ను క్రమంగా అమలు చేయండి. మీ సమాధానాన్ని తనిఖీ చేయడానికి ఇది వేగవంతమైన మార్గం. NULL మరియు duplicate సమస్యలనూ గుర్తించవచ్చు.
4. NULL‌ను ప్రత్యేక అంశంగా పరిగణించండి. IS NULL, COUNT(column) మరియు COUNT(*) మధ్య తేడా, AVGలో NULLలను వదిలేయడం, జాబితాలో NULL ఉన్నప్పుడు NOT IN ఎలా పనిచేస్తుంది, అలాగే సరిపోలని columns‌లో left join ఏమి ఉంచుతుందో సాధన చేయండి.
5. నిజమైన queries కూడా రాయండి. మా mock tests చదవడం, query అమలును అనుసరించడం వంటి నైపుణ్యాలను పెంచుతాయి. సమయ పరిమితిలో query టైప్ చేయడం సహజంగా అనిపించేలా, SQLite వంటి ఉచిత database‌లో కూడా queries రాయండి. కొన్ని tests మీ queryని అనేక test cases‌తో తనిఖీ చేస్తాయి. ఉదాహరణకు, TestGorilla తన SQLite test కోసం 10 కంటే ఎక్కువ test cases ఉన్నాయని పేర్కొంటుంది (TestGorilla).
6. Syntax మాత్రమే కాదు, ఫలితాన్ని కూడా తనిఖీ చేయండి. అమలయ్యే query కూడా తప్పు rows‌ను చూపవచ్చు. సమర్పించే ముందు, సరిపోలికలు లేకపోతే, duplicates ఉంటే లేదా NULLలు ఉంటే ఏమవుతుందో ఆలోచించండి.
7. నిజమైన వేగంతో సాధన చేయండి. TestGorilla యొక్క MySQL test వంటి చిన్న knowledge test‌లో 10 నిమిషాలకు 15 ప్రశ్నలు ఉంటే, ఒక్కో ప్రశ్నకు ఒక నిమిషం కంటే చాలా తక్కువ సమయం లభిస్తుంది (TestGorilla). ఆ రోజు పరీక్ష వేగం సహజంగా అనిపించేలా, సమయ పరిమితి ఉన్న పూర్తి mock tests తీసుకోండి.

సాధారణంగా స్కోరింగ్ ఎలా జరుగుతుంది

స్కోరింగ్ యజమాని మరియు ప్లాట్‌ఫారమ్‌పై ఆధారపడి ఉంటుంది. SQL కోసం ప్రామాణిక స్కోర్ లేదా అందరికీ వర్తించే ఉత్తీర్ణత మార్కు లేదు. మంచి ఫలితం అంటే ఏమిటో ప్రతి యజమాని నిర్ణయిస్తారు. Query ప్రశ్నలను ఎలా తనిఖీ చేస్తారో తెలిపే రెండు బహిరంగ ఉదాహరణలు:

• HackerRank database ప్రశ్నలు: మీ query ఫలితాన్ని ఆశించిన output‌తో పోల్చి, వాటికి స్వయంచాలకంగా స్కోర్ ఇస్తామని HackerRank చెబుతోంది. ఫలితం సరిపోతే పూర్తి స్కోర్ వస్తుంది, లేకపోతే సున్నా వస్తుంది. అయితే, యజమాని చేతితో సమీక్షించి పాక్షిక మార్కులు ఇవ్వవచ్చు. వరుసల క్రమాన్ని పట్టించుకోకూడదని కూడా యజమాని ఎంచుకోవచ్చు (HackerRank support).
• TestGorilla SQLite test: పరిష్కారంలోని క్లిష్టమైన సందర్భాలను తనిఖీ చేసే 10 కంటే ఎక్కువ test cases ఉపయోగించి అభ్యర్థులకు ర్యాంక్ ఇస్తామని TestGorilla చెబుతోంది (TestGorilla).

ఫలితాలను తరచుగా వరుసల వారీగా తనిఖీ చేస్తారు. అందువల్ల, దాదాపు సరైన query - ఉదాహరణకు, ఆర్డర్లు లేని కస్టమర్‌ను వదిలేసేది - సమాధానం ఇవ్వనప్పుడు వచ్చే స్కోర్‌నే పొందవచ్చు.

మా ప్రాక్టీస్ స్కోర్ అంటే, మా ప్రశ్నల్లో మీరు సరిగ్గా సమాధానం ఇచ్చిన ప్రశ్నల సంఖ్య. ఏ అంశంపై ఎక్కువ దృష్టి పెట్టాలో తెలుసుకునేందుకు, విభాగాల వారీగా వివరాలు కూడా చూపిస్తాం. ఇది ప్రాక్టీస్ స్కోర్ మాత్రమే: ఇది ఏ యజమాని లేదా ప్లాట్‌ఫారమ్ test‌లో వచ్చిన స్కోర్ కాదు, మీరు ఉత్తీర్ణులవుతారో లేదో కూడా సూచించదు.

సాధారణ తప్పులు

• = ఉపయోగించి NULLతో పోల్చడం. IS NULL మరియు IS NOT NULL ఉపయోగించండి. = NULL అయిన ఏదైనా విలువ తెలియనిదిగా పరిగణించబడుతుంది, కాబట్టి ఆ row ఫిల్టర్ అవుతుంది.
• WHEREలో left joinను ఫిల్టర్ చేయడం. కుడివైపు tableలోని columnsపై చేసే పరీక్ష, సరిపోలని rowsను తొలగిస్తుంది. వాటిని ఉంచాలంటే ఆ పరీక్షను ON clauseలో పెట్టండి.
• మొత్తం కోసం WHEREను ఉపయోగించడం. Aggregatesను GROUP BY తర్వాత HAVINGలో ఉపయోగించాలి.
• Group చేయని columnను ఎంచుకోవడం. ప్రామాణిక SQLలో ఎంచుకున్న ప్రతి columnను group చేయాలి లేదా aggregate చేయాలి. కొన్ని databases queryను అమలు చేసి మీ కోసం ఒక విలువను ఎంచుకుంటాయి, దాంతో పొరపాటు కనిపించకుండా పోతుంది.
• Duplicatesను మర్చిపోవడం. Join వల్ల rows మళ్లీ రావచ్చు, దీంతో SUM మరియు COUNT ఎక్కువగా లెక్కించబడతాయి. ఒకవైపు ఉన్న ప్రతి row, మరోవైపు ఒకటి కంటే ఎక్కువ rowsతో సరిపోలగలదా అని పరిశీలించండి.
• ఒక databaseలోని shortcutsపైనే ఆధారపడటం. కొన్ని functions మరియు limit syntax databasesను బట్టి మారుతాయి. ప్రామాణిక రూపాన్ని నేర్చుకుని, మీ testలో ఏ database ఉపయోగిస్తున్నారో తెలుసుకోండి.