SQL ટેસ્ટ પ્રેક્ટિસ

વાસ્તવિક test સામાન્ય રીતે કેવો હોય છે

એક જ પ્રકારની SQL test હોતી નથી. દરેક employer testing platform પસંદ કરે છે અથવા પોતાની test બનાવે છે, અને નક્કી કરે છે કે તેમાં કેટલા પ્રશ્નો હશે, કેટલો સમય મળશે અને કયો database વપરાશે. તમારી test વિશે જાણવા માટે job posting અથવા test invitation શ્રેષ્ઠ માર્ગદર્શન છે. જાહેરમાં ઉપલબ્ધ ઉદાહરણો પરથી તેની વિવિધતા જોઈ શકાય છે:

• HackerRankની SQL skills tests. HackerRank તેની SQL (Basic) skills testમાં 30 મિનિટમાં 2 પ્રશ્નો હોવાનું જણાવે છે. તેમાં સરળ queries જેવા વિષયો આવરી લેવાય છે (HackerRank). તેની SQL (Intermediate) testમાં 35 મિનિટમાં 2 પ્રશ્નો હોય છે, જેમાં complex joins જેવા વિષયો આવરી લેવાય છે (HackerRank). પોતાની HackerRank tests બનાવતા employers તેમાં database સંબંધિત પ્રશ્નો ઉમેરી શકે છે અને ઉમેદવારો કયા databases વાપરી શકે તે પસંદ કરી શકે છે (HackerRank support).
• Query લખવાનું કાર્ય. TestGorilla તેની SQLite coding testને 30 મિનિટનું કાર્ય ગણાવે છે, જેમાં મધ્યમ જટિલતાવાળા database સામે વાસ્તવિક પરિસ્થિતિ માટે query લખવાની હોય છે. તેમાં joining અને filtering, સાદી ગણતરીઓ, sorting, rounding અને બિનજરૂરી entries દૂર કરવા જેવા વિષયો આવરી લેવાય છે (TestGorilla).
• ટૂંકી જ્ઞાન-ચકાસણી test. TestGorilla તેની MySQL testમાં 101 પ્રશ્નોના ભંડારમાંથી પસંદ કરેલા 10 મિનિટમાં 15 પ્રશ્નો હોવાનું જણાવે છે (TestGorilla).

SQL testsમાં સામાન્ય રીતે આવરી લેવાતા વિષયો:

• 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 values: સરખામણી, ગણતરી અને સરેરાશમાં ખૂટતી values કેવી રીતે વર્તે છે.
• Subqueries: બીજી queryની અંદર આવેલી query, જેમાં IN, EXISTS અથવા એક જ value હોય.
• સાદી વિનંતી પરથી query લખવી, જેને ઘણી વાર તે અપેક્ષિત rows બરાબર આપે છે કે નહીં તેના આધારે ગુણ આપવામાં આવે છે.

અમારી mocksમાં શું આવરી લેવાય છે. દરેક full mockમાં 45 મિનિટમાં 18 પ્રશ્નો હોય છે અને તે ચાર વિભાગોમાં વહેંચાયેલી છે: SQL concepts (5), query શું પરિણામ આપે છે (6), query સુધારવી (4) અને યોગ્ય query પસંદ કરવી (3). તમે પાછા જઈને પ્રશ્નોને flag કરી શકો છો. અમે વિવિધ databasesમાં વાપરી શકાય તેવું standard SQL વાપરીએ છીએ, તેથી queriesનો અર્થ PostgreSQL, MySQL, SQL Server, SQLite અને મોટા ભાગના અન્ય databasesમાં એકસરખો રહે છે. અમારી mocksમાં queries વાંચવા, તેનો તર્ક અનુસરવા અને queries પસંદ કરવાની પ્રેક્ટિસ કરાવવામાં આવે છે; તમે લખેલી queries ચલાવવામાં આવતી નથી. ઘણી વાસ્તવિક SQL testsમાં એવી query લખવાની હોય છે જેનાં પરિણામો અપેક્ષિત પરિણામો સાથે સરખાવવામાં આવે. તેથી આ કૌશલ્યનો પાયો મજબૂત કરવા અમારી mocksથી વાંચવાની અને તર્ક અનુસરવાની પ્રેક્ટિસ કરો, અને SQLite જેવા મફત databaseમાં જાતે queries પણ લખો.

ઉકેલ સાથેના ઉદાહરણો ધરાવતા પ્રશ્નોના પ્રકાર

દરેક વિભાગ માટે એક ઉકેલ સાથેનું ઉદાહરણ, જેમાં લોકો સામાન્ય રીતે જે ભૂલ કરે છે તે પણ બતાવી છે.

1. SQLના ખ્યાલો. COUNT() અને COUNT(email) વચ્ચે શું તફાવત છે? COUNT() દરેક પંક્તિ ગણે છે; COUNT(email) માત્ર એવી પંક્તિઓ ગણે છે જેમાં email NULL નથી. ધ્યાન રાખો: દરેક ગણતરીમાં બધી પંક્તિઓ આવે છે એવું માનવું. મોટા ભાગનાં aggregate functions NULL મૂલ્યોને છોડી દે છે.

2. ક્વેરી શું પરિણામ આપે છે. scores ટેબલમાં 8, 5, NULL અને 8 મૂલ્યો છે. SELECT COUNT(DISTINCT score) શું પરિણામ આપે છે? અલગ-અલગ non-NULL મૂલ્યો 8 અને 5 છે, એટલે જવાબ 2 છે. ધ્યાન રાખો: NULLને એક મૂલ્ય ગણી લેવું અથવા પુનરાવર્તિત 8ને બે વાર ગણવું. ટેબલ લખો અને ક્વેરી જે રીતે કરે તેમ પંક્તિઓને એક પછી એક કાઢી નાખો.

3. ક્વેરી સુધારવી. એક ક્વેરીમાં WHERE city = 'Austin' OR city = 'Dallas' AND active = 1 છે, અને તે નિષ્ક્રિય Austin ગ્રાહકો પણ આપે છે. ANDનું મૂલ્યાંકન OR પહેલાં થાય છે, એટલે શરતનો સાચો અર્થ Austin અથવા સક્રિય Dallas એવો થાય છે. ઉકેલ માટે કૌંસ ઉમેરો: WHERE (city = 'Austin' OR city = 'Dallas') AND active = 1. ધ્યાન રાખો: શરતને ડાબેથી જમણે વાંચવી.

4. યોગ્ય ક્વેરી પસંદ કરવી. છેલ્લે મૂકાયેલા પાંચ ઑર્ડર જોઈએ છે. કઈ ક્વેરી યોગ્ય છે: ORDER BY order_date DESC સાથે 5ની મર્યાદા, કે ORDER BY order_date સાથે 5ની મર્યાદા? પહેલી. DESC વિના ક્રમ જૂનાથી નવું એવો રહેશે, એટલે સૌથી જૂના પાંચ ઑર્ડર મળશે. ધ્યાન રાખો: sortનો ક્રમ તપાસ્યા વિના યોગ્ય લાગતી ક્વેરી પસંદ કરવી. (ડેટાબેઝમાં મર્યાદા લખવાની રીત અલગ હોઈ શકે છે, જેમ કે LIMIT 5 અથવા FETCH FIRST 5 ROWS ONLY, એટલે તમારા testમાં કઈ રીત વપરાય છે તે તપાસો.)

5. શરતો સાથેના joins. left join પછી જમણી બાજુના ટેબલની કૉલમ પર WHERE શરત મૂકવાથી તે ચુપચાપ inner join બની જાય છે, કારણ કે મેળ ન ખાતી પંક્તિઓમાં ત્યાં NULL હોય છે અને શરત તેમને કાઢી નાખે છે. ધ્યાન રાખો: કઈ પંક્તિઓ ગાયબ થાય છે તે ન જોવું. પૂછો, "મેળ ન ખાતી પંક્તિનું શું થાય છે?"

તૈયારી કેવી રીતે કરવી

1. સૌપ્રથમ તમારું આમંત્રણ વાંચો. તમે કયા પ્લેટફોર્મનો ઉપયોગ કરશો, તમારી પાસે કેટલો સમય છે, તમારે queries લખવાની છે કે multiple-choice પ્રશ્નોના જવાબ આપવાના છે, અને તે કયા database પર ચાલે છે તે જાણો. ફોર્મેટમાં ઘણો ફેરફાર હોય છે, તેથી કોઈ ધારણા ન રાખો.
2. Query કયા ક્રમમાં ચાલે છે તે શીખો. પહેલાં FROM અને JOIN, પછી WHERE, GROUP BY, HAVING, SELECT અને ORDER BY. કયા તબક્કે કયો data ઉપલબ્ધ હોય છે તે જાણો, પછી મોટા ભાગના "આ ખોટું કેમ છે?" પ્રશ્નો સમજવા સરળ બને છે.
3. નાના tables હાથેથી તપાસો. ત્રણ કે ચાર rows લખો, પછી દરેક clause ક્રમ પ્રમાણે લાગુ કરો. જવાબ તપાસવાની આ સૌથી ઝડપી રીત છે, અને તે NULL તથા duplicatesની મુશ્કેલીઓ પણ પકડી લે છે.
4. NULLને અલગ વિષય તરીકે સમજો. IS NULL, COUNT(column) અને COUNT(*) વચ્ચેનો તફાવત, AVG દ્વારા NULL છોડી દેવા, યાદીમાં NULL હોય ત્યારે NOT IN, અને unmatched columnsમાં left join શું મૂકે છે તેની પ્રેક્ટિસ કરો.
5. વાસ્તવિક queries પણ લખો. અમારા mocks વાંચન અને tracingની કુશળતા વિકસાવે છે; સાથે SQLite જેવા મફત databaseમાં પણ queries લખો, જેથી સમયની મર્યાદામાં ટાઇપ કરવું સહજ લાગે. કેટલાક tests તમારી queryને અનેક cases સામે તપાસે છે. ઉદાહરણ તરીકે, TestGorilla તેના SQLite test માટે 10થી વધુ test casesનો ઉલ્લેખ કરે છે (TestGorilla).
6. માત્ર syntax નહીં, પરિણામ પણ તપાસો. ચાલતી query પણ ખોટી rows આપી શકે છે. જવાબ સબમિટ કરતાં પહેલાં વિચારો કે કોઈ matches ન મળે, duplicates હોય અથવા NULLs હોય તો શું થશે.
7. વાસ્તવિક ગતિએ પ્રેક્ટિસ કરો. TestGorillaના MySQL test જેવો ટૂંકો જ્ઞાન test, જેમાં 10 મિનિટમાં 15 પ્રશ્નો હોય છે, એટલે દરેક પ્રશ્ન માટે એક મિનિટથી ઘણો ઓછો સમય મળે છે (TestGorilla). આખા timed mocks આપો, જેથી testના દિવસે આ ગતિ સહજ લાગે.

સામાન્ય રીતે ગુણ કેવી રીતે ગણવામાં આવે છે

સ્કોરિંગ નોકરીદાતા અને પ્લેટફોર્મ પર આધારિત છે. SQL માટે કોઈ પ્રમાણભૂત સ્કોર કે સર્વસામાન્ય પાસ માર્ક નથી. સારો પરિણામ કોને કહેવાય તે દરેક નોકરીદાતા નક્કી કરે છે. ક્વેરી સંબંધિત પ્રશ્નો કેવી રીતે ચકાસવામાં આવે છે તેના બે જાહેર ઉદાહરણો:

• HackerRank ડેટાબેઝ પ્રશ્નો: HackerRank કહે છે કે તે તમારી ક્વેરીના પરિણામની અપેક્ષિત આઉટપુટ સાથે સરખામણી કરીને આપમેળે સ્કોર આપે છે. પરિણામ મેળ ખાય તો સંપૂર્ણ સ્કોર મળે છે અને અન્ય કોઈ પણ પરિણામ માટે શૂન્ય મળે છે, સિવાય કે નોકરીદાતા જાતે તેની સમીક્ષા કરીને આંશિક ગુણ આપે. નોકરીદાતા પંક્તિઓનો ક્રમ અવગણવાનું પણ પસંદ કરી શકે છે (HackerRank support).
• TestGorillaનું SQLite test: TestGorilla કહે છે કે ઉમેદવારોને ઉકેલની મુશ્કેલ પરિસ્થિતિઓ ચકાસતા 10થી વધુ test casesના આધારે ક્રમ આપવામાં આવે છે (TestGorilla).

પરિણામો ઘણી વાર પંક્તિ પ્રમાણે ચકાસવામાં આવે છે. તેથી, લગભગ સાચી ક્વેરી, જેમ કે એવી ક્વેરી જે ઓર્ડર ન ધરાવતા ગ્રાહકને કાઢી નાખે, તેને કોઈ જવાબ ન આપ્યો હોય એટલો જ સ્કોર મળી શકે છે.

અમારો અભ્યાસ સ્કોર એ અમારા પોતાના પ્રશ્નોમાંથી તમે સાચા જવાબ આપેલા પ્રશ્નોની સંખ્યા છે. તેમાં વિભાગ પ્રમાણે વિગતો આપવામાં આવે છે, જેથી તમે જાણી શકો કે કયા ભાગ પર ધ્યાન આપવું. આ અભ્યાસ સ્કોર છે: તે કોઈ નોકરીદાતા કે પ્લેટફોર્મના testનો સ્કોર નથી અને તમે પાસ થશો કે નહીં તેની આગાહી કરતો નથી.

સામાન્ય ભૂલો

• NULLની સરખામણી = વડે કરવી. IS NULL અને IS NOT NULL વાપરો. = NULL ધરાવતી કોઈપણ બાબત અજ્ઞાત ગણાય છે, એટલે તે row ફિલ્ટર થઈ જાય છે.
• WHEREમાં left join ફિલ્ટર કરવો. જમણી બાજુના tableના columns પરની શરત મેળ ન ખાતી rows કાઢી નાખે છે. એ rows રાખવી હોય, તો શરત ON clauseમાં મૂકો.
• કુલ માટે WHERE વાપરવું. Aggregate માટે GROUP BY પછી HAVING વાપરો.
• Group ન કરેલો column પસંદ કરવો. Standard SQLમાં દરેક પસંદ કરેલો column group થયેલો અથવા aggregate થયેલો હોવો જોઈએ. કેટલીક databases query ચલાવીને તમારા માટે કોઈ value પસંદ કરે છે, જેથી ભૂલ છુપાઈ જાય છે.
• ડુપ્લિકેટ્સ ભૂલી જવું. Join rowsનું પુનરાવર્તન કરી શકે છે, જેથી SUM અને COUNT વધીને આવે. એક બાજુની દરેક row બીજી બાજુની એકથી વધુ rows સાથે મેળ ખાઈ શકે છે કે નહીં તે તપાસો.
• એક databaseના shortcuts પર આધાર રાખવો. કેટલીક functions અને limit syntax databases પ્રમાણે અલગ હોય છે. Standard form શીખો અને તમારો test કઈ database વાપરે છે તે તપાસો.