SQL ടെസ്റ്റ് പരിശീലനം

യഥാർഥ ടെസ്റ്റ് സാധാരണയായി എങ്ങനെയിരിക്കും

ഒരൊറ്റ SQL ടെസ്റ്റ് എന്നൊന്നില്ല. ഓരോ തൊഴിലുടമയും ഒരു ടെസ്റ്റിംഗ് പ്ലാറ്റ്‌ഫോം തിരഞ്ഞെടുക്കുകയോ സ്വന്തം ടെസ്റ്റ് തയ്യാറാക്കുകയോ ചെയ്യും. ചോദ്യങ്ങളുടെ എണ്ണം, സമയപരിധി, ഉപയോഗിക്കുന്ന database എന്നിവയും അവർ തീരുമാനിക്കും. നിങ്ങളുടെ ടെസ്റ്റിനെക്കുറിച്ച് അറിയാൻ ജോലി പരസ്യമോ ടെസ്റ്റ് ക്ഷണമോ ആണ് ഏറ്റവും നല്ല മാർഗനിർദേശം. പൊതുവായി ലഭ്യമായ ഉദാഹരണങ്ങൾ വ്യത്യസ്ത രീതികൾ കാണിക്കുന്നു:

• HackerRank-ന്റെ SQL skills tests. HackerRank-ന്റെ SQL (Basic) skills test-ൽ ലളിതമായ queries പോലുള്ള വിഷയങ്ങൾ ഉൾപ്പെടുത്തി 30 മിനിറ്റിൽ 2 ചോദ്യങ്ങൾ ഉണ്ടെന്ന് HackerRank പറയുന്നു (HackerRank). SQL (Intermediate) test-ൽ സങ്കീർണ്ണമായ joins പോലുള്ള വിഷയങ്ങൾ ഉൾപ്പെടുത്തി 35 മിനിറ്റിൽ 2 ചോദ്യങ്ങൾ ഉണ്ടെന്നും പറയുന്നു (HackerRank). സ്വന്തം HackerRank tests തയ്യാറാക്കുന്ന തൊഴിലുടമകൾക്ക് database ചോദ്യങ്ങൾ ചേർക്കാനും ഉദ്യോഗാർഥികൾക്ക് ഉപയോഗിക്കാവുന്ന databases തിരഞ്ഞെടുക്കാനും കഴിയും (HackerRank support).
• ഒരു query എഴുതാനുള്ള ചുമതല. യഥാർഥ സാഹചര്യത്തെ അനുകരിക്കുന്ന ഒരു സന്ദർഭത്തിനായി, ഇടത്തരം സങ്കീർണ്ണതയുള്ള database-ൽ query എഴുതുന്നതിന് ചെലവഴിക്കുന്ന 30 മിനിറ്റാണ് തങ്ങളുടെ SQLite coding test എന്ന് TestGorilla വിവരിക്കുന്നു. അതിൽ joins, filtering, ലളിതമായ കണക്കുകൂട്ടലുകൾ, sorting, rounding, പ്രസക്തമല്ലാത്ത എൻട്രികൾ ഒഴിവാക്കൽ എന്നിവ ഉൾപ്പെടുന്നു (TestGorilla).
• ഒരു ഹ്രസ്വ വിജ്ഞാനപരിശോധന. 101 ചോദ്യങ്ങളുള്ള ഒരു ശേഖരത്തിൽനിന്നുള്ള 10 മിനിറ്റിൽ 15 ചോദ്യങ്ങളാണ് തങ്ങളുടെ MySQL test എന്ന് TestGorilla പറയുന്നു (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-കൾ: താരതമ്യങ്ങൾ, എണ്ണൽ, ശരാശരി എന്നിവയിൽ മൂല്യങ്ങൾ ഇല്ലാത്തപ്പോൾ അവ എങ്ങനെ പ്രവർത്തിക്കുന്നു.
• Subqueries: IN, EXISTS അല്ലെങ്കിൽ ഒറ്റ മൂല്യം ഉപയോഗിച്ചുള്ള, മറ്റൊരു query-ക്കുള്ളിലെ query.
• സാധാരണ ഭാഷയിലുള്ള അഭ്യർഥനയിൽ നിന്ന് query എഴുതൽ, പലപ്പോഴും പ്രതീക്ഷിച്ച rows കൃത്യമായി ലഭിക്കുന്നുണ്ടോ എന്നതിനെ അടിസ്ഥാനമാക്കി വിലയിരുത്തും.

ഞങ്ങളുടെ mocks-ൽ ഉൾപ്പെടുന്നത്. ഓരോ പൂർണ്ണ mock-ലും നാല് വിഭാഗങ്ങളിലായി 45 മിനിറ്റിൽ 18 ചോദ്യങ്ങൾ ഉണ്ടാകും: SQL concepts (5), query നൽകുന്ന ഫലം (6), query ശരിയാക്കൽ (4), ശരിയായ query തിരഞ്ഞെടുക്കൽ (3). നിങ്ങൾക്ക് മുമ്പത്തെ ചോദ്യങ്ങളിലേക്ക് മടങ്ങാനും ചോദ്യങ്ങൾ flag ചെയ്യാനും കഴിയും. ഞങ്ങൾ വിവിധ database-കളിൽ ашигിക്കാവുന്ന standard SQL ഉപയോഗിക്കുന്നതിനാൽ, queries-ийг PostgreSQL, MySQL, SQL Server, SQLite болон മിക്ക മറ്റ് databases-ലും ഒരേ അർഥത്തിൽ വായിക്കാം. ഞങ്ങളുടെ mocks-ൽ queries വായിക്കാനും അവയുടെ ഫലം കണ്ടെത്താനും ശരിയായ query തിരഞ്ഞെടുക്കാനും പരിശീലിക്കാം; നിങ്ങൾ എഴുതുന്ന queries പ്രവർത്തിപ്പിക്കില്ല. പല യഥാർഥ SQL tests-ലും പ്രതീക്ഷിച്ച ഫലങ്ങളുമായി താരതമ്യം ചെയ്ത് പരിശോധിക്കുന്ന query എഴുതാൻ ആവശ്യപ്പെടും. അതിനാൽ, അതിന് ആവശ്യമായ വായനയും ഫലം കണ്ടെത്തലും ഞങ്ങളുടെ mocks ഉപയോഗിച്ച് പരിശീലിക്കുക. കൂടാതെ SQLite പോലുള്ള സൗജന്യ database-ൽ സ്വയം queries എഴുതിയും പരിശീലിക്കുക.

ഉദാഹരണങ്ങൾ സഹിതമുള്ള ചോദ്യങ്ങളുടെ തരങ്ങൾ

ഓരോ വിഭാഗത്തിനും ഒരു ഉദാഹരണം, മിക്കവരും വീഴുന്ന കെണിയോടൊപ്പം.

1. SQL ആശയങ്ങൾ. COUNT()-ഉം COUNT(email)-ഉം തമ്മിലുള്ള വ്യത്യാസം എന്താണ്? COUNT() എല്ലാ rows-ഉം എണ്ണുന്നു; email NULL അല്ലാത്ത rows മാത്രമാണ് COUNT(email) എണ്ണുന്നത്. കെണി: എല്ലാ count-ഉം എല്ലാ rows-ഉം ഉൾപ്പെടുത്തുമെന്ന് കരുതുന്നത്. മിക്ക aggregate functions-ഉം NULL-കൾ ഒഴിവാക്കും.

2. Query എന്താണ് നൽകുന്നത്. scores എന്ന table-ൽ 8, 5, NULL, 8 എന്നീ values байна. SELECT COUNT(DISTINCT score) എന്താണ് നൽകുക? NULL അല്ലാത്ത വ്യത്യസ്ത values 8-ഉം 5-ഉം ആണ്, അതിനാൽ ഉത്തരം 2. കെണി: NULL-നെ ഒരു value ആയി എണ്ണുന്നത്, അല്ലെങ്കിൽ ആവർത്തിക്കുന്ന 8-നെ രണ്ടുതവണ എണ്ണുന്നത്. Table എഴുതി, query ചെയ്യുന്നതുപോലെ rows ഒഴിവാക്കിക്കൊണ്ട് നോക്കുക.

3. Query തിരുത്തൽ. ഒരു query-യിൽ WHERE city = 'Austin' OR city = 'Dallas' AND active = 1 എന്ന് എഴുതിയിരിക്കുന്നു; ഇത് inactive Austin customers-നെയും നൽകുന്നു. OR-ന് മുമ്പ് AND വിലയിരുത്തുന്നതിനാൽ, ഈ condition-ന്റെ യഥാർഥ അർത്ഥം Austin, അല്ലെങ്കിൽ active ആയ Dallas എന്നാണ്. Brackets ചേർക്കുന്നതാണ് പരിഹാരം: WHERE (city = 'Austin' OR city = 'Dallas') AND active = 1. കെണി: condition ഇടത്തുനിന്ന് വലത്തോട്ട് വായിക്കുന്നത്.

4. ശരിയായ query തിരഞ്ഞെടുക്കൽ. ഏറ്റവും പുതിയ അഞ്ച് orders വേണം. ഏതാണ് ശരി: limit of 5-നൊപ്പം ORDER BY order_date DESC ആണോ, അതോ limit of 5-നൊപ്പം ORDER BY order_date ആണോ? ആദ്യത്തേത്. DESC ഇല്ലെങ്കിൽ പഴയത് ആദ്യം എന്ന ക്രമത്തിൽ sort ചെയ്യും, അതിനാൽ ഏറ്റവും പഴയ അഞ്ച് ലഭിക്കും. കെണി: sort direction പരിശോധിക്കാതെ ശരിയെന്ന് തോന്നുന്ന query തിരഞ്ഞെടുക്കുന്നത്. (LIMIT 5 അല്ലെങ്കിൽ FETCH FIRST 5 ROWS ONLY എന്നിങ്ങനെ databases-ൽ limit എഴുതുന്ന രീതി വ്യത്യസ്തമായിരിക്കും. നിങ്ങളുടെ test ഏത് രീതിയാണ് ഉപയോഗിക്കുന്നതെന്ന് പരിശോധിക്കുക.)

5. Conditions ഉള്ള Joins. Left join-ന് ശേഷം right table-ന്റെ column-ൽ WHERE test ചേർത്താൽ, അത് അറിയാതെ inner join ആയി хувിയുന്നു. Match ഇല്ലാത്ത rows-ൽ ആ column NULL байх тул test അവയെ നീക്കം ചെയ്യും. കെണി: ഏത് rows ആണ് അപ്രത്യക്ഷമാകുന്നതെന്ന് ശ്രദ്ധിക്കാതിരിക്കുന്നത്. "Match ഇല്ലാത്ത ഒരു row-ന് എന്ത് സംഭവിക്കും?" എന്ന് ചോദിക്കുക.

എങ്ങനെ തയ്യാറെടുക്കാം

1. ആദ്യം നിങ്ങളുടെ ക്ഷണക്കത്ത് വായിക്കുക. ഏത് പ്ലാറ്റ്‌ഫോമാണ് ഉപയോഗിക്കേണ്ടത്, എത്ര സമയമുണ്ട്, queries എഴുതണോ multiple choice ചോദ്യങ്ങൾക്ക് ഉത്തരം നൽകണോ, ഏത് database ആണ് ഉപയോഗിക്കുന്നത് എന്നിവ കണ്ടെത്തുക. ഫോർമാറ്റുകൾ തമ്മിൽ വളരെയധികം വ്യത്യാസമുള്ളതിനാൽ മുൻകൂട്ടി ഊഹിക്കരുത്.
2. ഒരു query പ്രവർത്തിക്കുന്ന ക്രമം പഠിക്കുക. ആദ്യം FROM, JOIN; തുടർന്ന് WHERE, GROUP BY, HAVING, SELECT, ORDER BY. ഏത് ഘട്ടത്തിലാണ് ഏത് ഡാറ്റ ലഭ്യമാകുന്നത് എന്ന് മനസ്സിലാക്കിയാൽ, “ഇത് തെറ്റായത് എന്തുകൊണ്ട്?” എന്ന മിക്ക ചോദ്യങ്ങളും വ്യക്തമാകും.
3. ചെറിയ പട്ടികകൾ കൈകൊണ്ട് പരിശോധിക്കുക. മൂന്നോ നാലോ rows എഴുതിയിട്ട് ഓരോ clause-ഉം ക്രമത്തിൽ പ്രയോഗിക്കുക. ഉത്തരം പരിശോധിക്കാനുള്ള ഏറ്റവും വേഗമുള്ള മാർഗമാണിത്. NULL, duplicate എന്നിവയുമായി ബന്ധപ്പെട്ട കെണികളും ഇതിലൂടെ കണ്ടെത്താം.
4. NULL-നെ ഒരു പ്രത്യേക വിഷയമായി കാണുക. IS NULL, COUNT(column), COUNT(*) എന്നിവ തമ്മിലുള്ള വ്യത്യാസം, AVG-യിൽ NULL-കൾ ഒഴിവാകുന്നത്, പട്ടികയിൽ NULL ഉള്ളപ്പോൾ NOT IN-ന്റെ പെരുമാറ്റം, പൊരുത്തമില്ലാത്ത columns-ൽ left join എന്താണ് നൽകുന്നത് എന്നിവ പരിശീലിക്കുക.
5. യഥാർത്ഥ queries-ഉം എഴുതുക. ഞങ്ങളുടെ mocks വായിക്കാനും query-കൾ ഘട്ടംഘട്ടമായി പരിശോധിക്കാനുമുള്ള കഴിവ് വളർത്തുന്നു. സമയപരിധിക്കുള്ളിൽ query ടൈപ്പ് ചെയ്യുന്നത് പരിചിതമാകാൻ SQLite പോലുള്ള സൗജന്യ database-ലും query-കൾ എഴുതുക. ചില tests നിങ്ങളുടെ query പല test cases ഉപയോഗിച്ച് പരിശോധിക്കും. TestGorilla അവരുടെ SQLite test-നായി വിവരിക്കുന്ന 10-ൽ കൂടുതൽ test cases അതിന് ഉദാഹരണമാണ് (TestGorilla).
6. Syntax മാത്രമല്ല, ഫലവും പരിശോധിക്കുക. പ്രവർത്തിക്കുന്ന query പോലും തെറ്റായ rows നൽകാം. സമർപ്പിക്കുന്നതിന് മുമ്പ്, പൊരുത്തങ്ങളൊന്നുമില്ലെങ്കിൽ, duplicates ഉണ്ടെങ്കിൽ, അല്ലെങ്കിൽ NULL-കൾ ഉണ്ടെങ്കിൽ എന്ത് സംഭവിക്കുമെന്ന് ചിന്തിക്കുക.
7. യഥാർത്ഥ സമയവേഗത്തിൽ പരിശീലിക്കുക. TestGorilla-യുടെ MySQL test പോലുള്ള ഒരു ചെറിയ വിജ്ഞാനപരിശോധനയിൽ 10 മിനിറ്റിൽ 15 ചോദ്യങ്ങളുണ്ടെങ്കിൽ, ഓരോ ചോദ്യത്തിനും ഒരു മിനിറ്റിൽ വളരെ കുറവ് സമയമാണ് ലഭിക്കുക (TestGorilla). ആ ദിവസത്തെ വേഗം പരിചിതമാകാൻ മുഴുവൻ timed mocks ചെയ്യുക.

സ്കോറിംഗ് സാധാരണയായി എങ്ങനെ നടക്കുന്നു

സ്കോറിംഗ് തൊഴിലുടമയെയും പ്ലാറ്റ്‌ഫോമിനെയും ആശ്രയിച്ചിരിക്കുന്നു. 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 ആയ എന്തും അറിയപ്പെടാത്ത മൂല്യമാണ്, അതിനാൽ ആ വരി ഫിൽട്ടർ ചെയ്യപ്പെടും.
• Left join-ൽ WHERE ഉപയോഗിച്ച് ഫിൽട്ടർ ചെയ്യുന്നത്. വലതുവശത്തെ പട്ടികയിലെ കോളങ്ങളിൽ നടത്തുന്ന പരിശോധന, പൊരുത്തമില്ലാത്ത വരികൾ നീക്കം ചെയ്യും. അവ നിലനിർത്തണമെങ്കിൽ ആ പരിശോധന ON clause-ൽ ചേർക്കുക.
• ഒരു മൊത്തം കണക്കാക്കാൻ WHERE ഉപയോഗിക്കുന്നത്. GROUP BY-യ്ക്ക് ശേഷം HAVING-ലാണ് aggregates ഉപയോഗിക്കേണ്ടത്.
• ഗ്രൂപ്പ് ചെയ്യാത്ത കോളം തിരഞ്ഞെടുക്കുന്നത്. standard SQL-ൽ തിരഞ്ഞെടുക്കുന്ന ഓരോ കോളവും ഗ്രൂപ്പ് ചെയ്യുകയോ aggregate ചെയ്യുകയോ വേണം. ചില ഡാറ്റാബേസുകളിൽ ഇത് പ്രവർത്തിച്ചേക്കാം; അപ്പോൾ അവ നിങ്ങൾക്കായി ഒരു മൂല്യം തിരഞ്ഞെടുക്കും, ഇത് പിശക് മറച്ചുവെക്കും.
• ആവർത്തനങ്ങൾ മറക്കുന്നത്. ഒരു join വരികൾ ആവർത്തിക്കാം, അതുവഴി SUM, COUNT എന്നിവയുടെ മൂല്യങ്ങൾ കൂടും. ഒരു വശത്തെ ഓരോ വരിയും മറുവശത്തെ ഒന്നിലധികം വരികളുമായി പൊരുത്തപ്പെടുമോ എന്ന് പരിശോധിക്കുക.
• ഒരു ഡാറ്റാബേസിന്റെ മാത്രം എളുപ്പവഴികളെ ആശ്രയിക്കുന്നത്. ചില ഫംഗ്ഷനുകളും limit syntax-ഉം ഡാറ്റാബേസുകൾക്കിടയിൽ വ്യത്യാസപ്പെട്ടിരിക്കും. standard രൂപം പഠിക്കുകയും നിങ്ങളുടെ test-ൽ ഏത് ഡാറ്റാബേസാണ് ഉപയോഗിക്കുന്നതെന്ന് പരിശോധിക്കുകയും ചെയ്യുക.