SQL ଟେଷ୍ଟ ଅଭ୍ୟାସ

ପ୍ରକୃତ ପରୀକ୍ଷା ସାଧାରଣତଃ କିପରି ହୋଇଥାଏ

କୌଣସି ଏକମାତ୍ର SQL ପରୀକ୍ଷା ନାହିଁ। ପ୍ରତ୍ୟେକ ନିଯୁକ୍ତିଦାତା ଏକ testing platform ବାଛନ୍ତି, କିମ୍ବା ନିଜର ପରୀକ୍ଷା ତିଆରି କରନ୍ତି। ସେମାନେ କେତେଟି ପ୍ରଶ୍ନ ରହିବ, କେତେ ସମୟ ମିଳିବ ଏବଂ କେଉଁ database ବ୍ୟବହାର ହେବ ତାହା ମଧ୍ୟ ନିର୍ଣ୍ଣୟ କରନ୍ତି। ଆପଣଙ୍କ ପରୀକ୍ଷା ବିଷୟରେ ଜାଣିବା ପାଇଁ ଚାକିରି ବିଜ୍ଞପ୍ତି କିମ୍ବା ପରୀକ୍ଷା ନିମନ୍ତ୍ରଣ ସବୁଠାରୁ ଭଲ ମାର୍ଗଦର୍ଶକ। ସାର୍ବଜନୀନ ଉଦାହରଣଗୁଡ଼ିକରୁ ଏହି ଭିନ୍ନତା ଦେଖିବାକୁ ମିଳେ:

• HackerRank ର SQL skills tests। HackerRank ରେ SQL (Basic) skills test 30 ମିନିଟ୍‌ରେ 2ଟି ପ୍ରଶ୍ନ ଥିବା ବୋଲି ଦର୍ଶାଯାଇଛି। ଏଥିରେ ସରଳ queries ପରି ବିଷୟ ରହିଛି (HackerRank)। ଏହାର SQL (Intermediate) test ରେ 35 ମିନିଟ୍‌ରେ 2ଟି ପ୍ରଶ୍ନ ରହିଛି ଏବଂ complex joins ପରି ବିଷୟ ଅନ୍ତର୍ଭୁକ୍ତ (HackerRank)। ନିଜସ୍ୱ HackerRank test ତିଆରି କରୁଥିବା ନିଯୁକ୍ତିଦାତାମାନେ database ପ୍ରଶ୍ନ ଯୋଡ଼ିପାରନ୍ତି ଏବଂ ଆବେଦନକାରୀମାନେ କେଉଁ database ବ୍ୟବହାର କରିପାରିବେ ତାହା ବାଛିପାରନ୍ତି (HackerRank support)।
• ଏକ query ଲେଖିବାର କାର୍ଯ୍ୟ। TestGorilla ଏହାର SQLite coding test କୁ 30 ମିନିଟ୍ ଧରି ଏକ ମଧ୍ୟମ ଜଟିଳତାର database ଉପରେ ବାସ୍ତବ ପରିସ୍ଥିତି ପାଇଁ query ଲେଖିବାର ପରୀକ୍ଷା ଭାବେ ବର୍ଣ୍ଣନା କରେ। ଏଥିରେ joining ଏବଂ filtering, ସରଳ ହିସାବ, sorting, rounding ଏବଂ ଅପ୍ରାସଙ୍ଗିକ ରେକର୍ଡ ବାଦ ଦେବା ଅନ୍ତର୍ଭୁକ୍ତ (TestGorilla)।
• ଏକ ସଂକ୍ଷିପ୍ତ ଜ୍ଞାନ ପରୀକ୍ଷା। TestGorilla ର MySQL test ରେ 101ଟି ପ୍ରଶ୍ନର ଏକ ପ୍ରଶ୍ନଭଣ୍ଡାରରୁ ନିଆଯାଇଥିବା 10 ମିନିଟ୍‌ରେ 15ଟି ପ୍ରଶ୍ନ ଥିବା ବୋଲି ଦର୍ଶାଯାଇଛି (TestGorilla)।

SQL ପରୀକ୍ଷାଗୁଡ଼ିକରେ ସାଧାରଣତଃ ଦେଖାଯାଉଥିବା ବିଷୟଗୁଡ଼ିକ:

• Filtering ଏବଂ sorting: SELECT, WHERE, ORDER BY ଏବଂ AND, OR, IN ଓ BETWEEN ସହିତ conditions।
• Joins: inner ଏବଂ left joins, ଏବଂ ମେଳ ନଥିବା rows ସହିତ କ'ଣ ହୁଏ।
• Grouping: COUNT, SUM, AVG, MIN ଏବଂ MAX ସହିତ GROUP BY, ଏବଂ groups କୁ filter କରିବା ପାଇଁ HAVING।
• NULLs: ତୁଳନା, ଗଣନା ଏବଂ ହାରାହାରିରେ ନିଖୋଜ ମୂଲ୍ୟଗୁଡ଼ିକ କିପରି କାମ କରେ।
• Subqueries: ଅନ୍ୟ ଏକ query ଭିତରେ ଥିବା query, IN, EXISTS କିମ୍ବା ଗୋଟିଏ ମୂଲ୍ୟ ସହିତ।
• ସାଧାରଣ ଭାଷାରେ ଦିଆଯାଇଥିବା ଅନୁରୋଧ ଅନୁଯାୟୀ query ଲେଖିବା, ଯେଉଁଥିରେ ଏହା ଠିକ୍ ଆଶାକରାଯାଇଥିବା rows ଫେରାଉଛି କି ନାହିଁ, ସେହି ଆଧାରରେ ପ୍ରାୟତଃ ମୂଲ୍ୟାୟନ କରାଯାଏ।

ଆମର mock tests ରେ କ'ଣ ରହିଛି। ପ୍ରତ୍ୟେକ ପୂର୍ଣ୍ଣ mock ରେ ଚାରିଟି ବିଭାଗରେ 45 ମିନିଟ୍‌ରେ 18ଟି ପ୍ରଶ୍ନ ରହିଛି: SQL ଧାରଣା (5), query କ'ଣ ଫଳାଫଳ ଦିଏ (6), query ସଠିକ୍ କରିବା (4) ଏବଂ ଠିକ୍ query ବାଛିବା (3)। ଆପଣ ପଛକୁ ଯାଇ ପ୍ରଶ୍ନଗୁଡ଼ିକୁ ଚିହ୍ନିତ କରିପାରିବେ। ଆମେ ବିଭିନ୍ନ database ରେ ଚାଲିପାରୁଥିବା standard SQL ବ୍ୟବହାର କରୁ, ତେଣୁ queries ର ଅର୍ଥ PostgreSQL, MySQL, SQL Server, SQLite ଏବଂ ଅନ୍ୟାନ୍ୟ ଅଧିକାଂଶ database ରେ ସମାନ। ଆମର mock tests ରେ queries ପଢ଼ିବା, ସେଗୁଡ଼ିକ କିପରି କାମ କରେ ଅନୁସରଣ କରିବା ଏବଂ ବାଛିବାର ଅଭ୍ୟାସ ହୁଏ; ଆପଣ ଲେଖିଥିବା queries ଏଥିରେ ଚଲାଯାଏ ନାହିଁ। ଅନେକ ବାସ୍ତବ SQL ପରୀକ୍ଷାରେ ଆପଣଙ୍କୁ ଏପରି query ଲେଖିବାକୁ କୁହାଯାଏ ଯାହାକୁ ଆଶାକରାଯାଇଥିବା ଫଳାଫଳ ସହିତ ଯାଞ୍ଚ କରାଯାଏ। ତେଣୁ ଏହା ପଛରେ ଥିବା ପଢ଼ିବା ଓ ଅନୁସରଣ କରିବାର ଦକ୍ଷତା ଗଢ଼ିବା ପାଇଁ ଆମର mock tests ବ୍ୟବହାର କରନ୍ତୁ, ଏବଂ SQLite ପରି ଏକ ମାଗଣା database ରେ ନିଜେ ମଧ୍ୟ queries ଲେଖନ୍ତୁ।

ସମାଧାନ ସହ ଉଦାହରଣ ଥିବା ପ୍ରଶ୍ନର ପ୍ରକାର

ପ୍ରତ୍ୟେକ ଅଂଶ ପାଇଁ ଗୋଟିଏ ଉଦାହରଣ, ଯେଉଁଥିରେ ଅଧିକାଂଶ ଲୋକ କରୁଥିବା ଭୁଲଟି ମଧ୍ୟ ଦର୍ଶାଯାଇଛି।

1. SQL ଧାରଣା। COUNT() ଏବଂ COUNT(email) ମଧ୍ୟରେ ପାର୍ଥକ୍ୟ କ’ଣ? COUNT() ପ୍ରତ୍ୟେକ row ଗଣେ; COUNT(email) କେବଳ ସେହି row ଗଣେ ଯେଉଁଠାରେ email ର ମୂଲ୍ୟ NULL ନୁହେଁ। ଫାନ୍ଦ: ପ୍ରତ୍ୟେକ count ସମସ୍ତ row କୁ ଗଣେ ବୋଲି ଧରିନେବା। ଅଧିକାଂଶ aggregate function NULL କୁ ଛାଡ଼ିଦିଏ।

2. Query କ’ଣ ଫେରାଏ। scores table ରେ 8, 5, NULL ଏବଂ 8 ମୂଲ୍ୟ ଅଛି। SELECT COUNT(DISTINCT score) କ’ଣ ଫେରାଏ? ଭିନ୍ନ ଭିନ୍ନ non-NULL ମୂଲ୍ୟ ହେଉଛି 8 ଏବଂ 5, ତେଣୁ ଉତ୍ତର 2। ଫାନ୍ଦ: NULL କୁ ଏକ ମୂଲ୍ୟ ଭାବେ ଗଣିବା କିମ୍ବା ପୁନରାବୃତ୍ତ 8 କୁ ଦୁଇଥର ଗଣିବା। Table ଟି ଲେଖନ୍ତୁ ଏବଂ query ଯେପରି କରିବ, ସେହିଭଳି row ଗୁଡ଼ିକୁ କାଟିଦିଅନ୍ତୁ।

3. Query ଠିକ୍ କରିବା। ଏକ query ରେ WHERE city = 'Austin' OR city = 'Dallas' AND active = 1 ରହିଛି, ଏବଂ ଏହା inactive Austin ଗ୍ରାହକଙ୍କୁ ମଧ୍ୟ ଫେରାଏ। AND କୁ OR ପୂର୍ବରୁ ମୂଲ୍ୟାୟନ କରାଯାଏ, ତେଣୁ condition ର ପ୍ରକୃତ ଅର୍ଥ ହେଉଛି Austin, କିମ୍ବା active Dallas। ସମାଧାନ ହେଉଛି ବ୍ରାକେଟ୍: WHERE (city = 'Austin' OR city = 'Dallas') AND active = 1। ଫାନ୍ଦ: condition କୁ ବାମରୁ ଡାହାଣକୁ ପଢ଼ିବା।

4. ଠିକ୍ query ବାଛିବା। ସବୁଠାରୁ ନୂଆ ପାଞ୍ଚଟି order ଦରକାର। କେଉଁଟି ଠିକ୍: limit 5 ସହ ORDER BY order_date DESC, କିମ୍ବା limit 5 ସହ ORDER BY order_date? ପ୍ରଥମଟି। DESC ନଥିଲେ sort ପୁରୁଣାରୁ ନୂଆକୁ ହୁଏ, ତେଣୁ ସବୁଠାରୁ ପୁରୁଣା ପାଞ୍ଚଟି ମିଳିବ। ଫାନ୍ଦ: sort ର ଦିଗ ଯାଞ୍ଚ ନକରି ଠିକ୍ ଦେଖାଯାଉଥିବା query ବାଛିବା। (Database ଅନୁସାରେ limit ଲେଖିବାର ଧାରା ଭିନ୍ନ, ଯେପରିକି LIMIT 5 କିମ୍ବା FETCH FIRST 5 ROWS ONLY। ତେଣୁ ଆପଣଙ୍କ test ରେ କେଉଁଟି ବ୍ୟବହାର ହେଉଛି ଯାଞ୍ଚ କରନ୍ତୁ।)

5. Condition ସହ Joins। Left join ପରେ right table ର column ଉପରେ WHERE condition ଦେଲେ, ତାହା ନଜାଣତେ inner join ହୋଇଯାଏ। କାରଣ, match ନଥିବା row ରେ ସେଠାରେ NULL ଥାଏ ଏବଂ condition ସେଗୁଡ଼ିକୁ ବାହାର କରିଦିଏ। ଫାନ୍ଦ: କେଉଁ row ଗାଏବ ହେଉଛି ତାହା ଧ୍ୟାନ ନଦେବା। ପଚାରନ୍ତୁ, "ଯେଉଁ row ର କୌଣସି match ନାହିଁ, ତାହାର କ’ଣ ହୁଏ?"

କିପରି ପ୍ରସ୍ତୁତି ନେବେ

1. ପ୍ରଥମେ ଆପଣଙ୍କ ଆମନ୍ତ୍ରଣ ପଢ଼ନ୍ତୁ। ଆପଣ କେଉଁ ପ୍ଲାଟଫର୍ମ ବ୍ୟବହାର କରିବେ, କେତେ ସମୟ ପାଇବେ, query ଲେଖିବେ ନା multiple choice ପ୍ରଶ୍ନର ଉତ୍ତର ଦେବେ, ଏବଂ ଏହା କେଉଁ database ରେ ଚାଲିବ, ତାହା ଜାଣନ୍ତୁ। ପରୀକ୍ଷାର ଢାଞ୍ଚା ଏତେ ଭିନ୍ନ ହୋଇପାରେ ଯେ ଅନୁମାନ କରିବା ଠିକ୍ ନୁହେଁ।
2. ଏକ query କେଉଁ କ୍ରମରେ ଚାଲେ ତାହା ଶିଖନ୍ତୁ। ପ୍ରଥମେ FROM ଏବଂ JOIN, ତାପରେ WHERE, GROUP BY, HAVING, SELECT ଏବଂ ORDER BY। କେଉଁ ପଦକ୍ଷେପରେ କେଉଁ data ଦେଖାଯାଏ ଜାଣିଲେ, ଅଧିକାଂଶ "ଏହା ଭୁଲ କାହିଁକି?" ପ୍ରଶ୍ନ ବୁଝିବା ସହଜ ହୁଏ।
3. ଛୋଟ table ଗୁଡ଼ିକୁ ହାତରେ ଯାଞ୍ଚ କରନ୍ତୁ। ତିନି କିମ୍ବା ଚାରିଟି row ଲେଖନ୍ତୁ, ତାପରେ ପ୍ରତ୍ୟେକ clause କୁ କ୍ରମରେ ପ୍ରୟୋଗ କରନ୍ତୁ। ଉତ୍ତର ଯାଞ୍ଚ କରିବାର ଏହା ସବୁଠାରୁ ଶୀଘ୍ର ଉପାୟ, ଏବଂ NULL ଓ duplicate ଜନିତ ଭୁଲ ଧରିବାରେ ସାହାଯ୍ୟ କରେ।
4. NULL କୁ ଏକ ଅଲଗା ବିଷୟ ଭାବେ ଧରନ୍ତୁ। IS NULL, COUNT(column) ଏବଂ COUNT(*) ମଧ୍ୟର ତଫାତ, AVG ଦ୍ୱାରା NULL ଛାଡ଼ି ଦିଆଯିବା, ତାଲିକାରେ NULL ଥିବାବେଳେ NOT IN, ଏବଂ left join ମେଳ ନଥିବା column ଗୁଡ଼ିକରେ କ'ଣ ରଖେ, ସେଗୁଡ଼ିକ ଅଭ୍ୟାସ କରନ୍ତୁ।
5. ପ୍ରକୃତ query ମଧ୍ୟ ଲେଖନ୍ତୁ। ଆମର mock test ଗୁଡ଼ିକ ପଢ଼ିବା ଓ ତଥ୍ୟ ଅନୁସରଣ କରିବାର ଦକ୍ଷତା ବଢ଼ାଏ। ସମୟ ମଧ୍ୟରେ query ଟାଇପ୍ କରିବା ସ୍ୱାଭାବିକ ଲାଗିବା ପାଇଁ SQLite ପରି ଏକ ମାଗଣା database ରେ ମଧ୍ୟ query ଲେଖନ୍ତୁ। କିଛି ପରୀକ୍ଷା ଅନେକ ପରିସ୍ଥିତିରେ ଆପଣଙ୍କ query ଯାଞ୍ଚ କରେ। ଉଦାହରଣ ସ୍ୱରୂପ, TestGorilla ଏହାର SQLite ପରୀକ୍ଷା ପାଇଁ 10 ରୁ ଅଧିକ test case ବିଷୟରେ କହିଛି (TestGorilla).
6. କେବଳ syntax ନୁହେଁ, ଫଳାଫଳ ଯାଞ୍ଚ କରନ୍ତୁ। ଚାଲୁଥିବା query ମଧ୍ୟ ଭୁଲ row ଫେରାଇପାରେ। ଉତ୍ତର ଦାଖଲ କରିବା ପୂର୍ବରୁ, କୌଣସି ମେଳ ନମିଳିଲେ, duplicate ଥିଲେ ଏବଂ NULL ଥିଲେ କ'ଣ ହେବ, ଭାବନ୍ତୁ।
7. ପ୍ରକୃତ ପରୀକ୍ଷାର ଗତିରେ ଅଭ୍ୟାସ କରନ୍ତୁ। TestGorilla ର MySQL ପରୀକ୍ଷା ପରି ଏକ ସଂକ୍ଷିପ୍ତ ଜ୍ଞାନ ପରୀକ୍ଷାରେ, 10 ମିନିଟ୍‌ରେ 15ଟି ପ୍ରଶ୍ନ ଥିଲେ, ପ୍ରତ୍ୟେକ ପ୍ରଶ୍ନ ପାଇଁ ଏକ ମିନିଟ୍‌ଠାରୁ ବହୁତ କମ୍ ସମୟ ମିଳେ (TestGorilla)। ପରୀକ୍ଷା ଦିନ ଗତି ସ୍ୱାଭାବିକ ଲାଗିବା ପାଇଁ ପୂରା timed mock test ଦିଅନ୍ତୁ।

ସାଧାରଣତଃ ସ୍କୋର କିପରି ନିର୍ଣ୍ଣୟ କରାଯାଏ

ସ୍କୋରିଂ ନିଯୁକ୍ତିଦାତା ଏବଂ ପ୍ଲାଟଫର୍ମ ଉପରେ ନିର୍ଭର କରେ। କୌଣସି ମାନକ SQL ସ୍କୋର କିମ୍ବା ସାର୍ବଜନୀନ ଉତ୍ତୀର୍ଣ୍ଣ ମାନଦଣ୍ଡ ନାହିଁ। କେଉଁ ଫଳାଫଳକୁ ଭଲ ବୋଲି ଧରାଯିବ, ତାହା ପ୍ରତ୍ୟେକ ନିଯୁକ୍ତିଦାତା ସ୍ଥିର କରନ୍ତି। Query ପ୍ରଶ୍ନଗୁଡ଼ିକୁ କିପରି ଯାଞ୍ଚ କରାଯାଏ, ତାହାର ଦୁଇଟି ସାର୍ବଜନୀନ ଉଦାହରଣ:

• HackerRank ଡାଟାବେସ୍ ପ୍ରଶ୍ନ: HackerRank କହେ ଯେ ଆପଣଙ୍କ query ର ଫଳାଫଳକୁ ଆଶାକରାଯାଇଥିବା ଆଉଟପୁଟ୍ ସହ ତୁଳନା କରି ଏଗୁଡ଼ିକର ସ୍କୋର ସ୍ୱୟଂଚାଳିତ ଭାବେ ଦିଆଯାଏ। ଫଳାଫଳ ମେଳ ହେଲେ ପୂରା ସ୍କୋର ମିଳେ, ଅନ୍ୟଥା ଶୂନ୍ୟ ମିଳେ; ତେବେ ନିଯୁକ୍ତିଦାତା ହାତରେ ଯାଞ୍ଚ କରି ଆଂଶିକ ନମ୍ବର ଦେଇପାରନ୍ତି। ନିଯୁକ୍ତିଦାତା ଧାଡ଼ିର କ୍ରମକୁ ଅଣଦେଖା କରିବାକୁ ମଧ୍ୟ ବାଛିପାରନ୍ତି (HackerRank ସହାୟତା).
• TestGorilla ର SQLite ପରୀକ୍ଷା: TestGorilla କହେ ଯେ ସମାଧାନର ବିଶେଷ ପରିସ୍ଥିତିଗୁଡ଼ିକୁ ଯାଞ୍ଚ କରୁଥିବା 10 ରୁ ଅଧିକ test case ବ୍ୟବହାର କରି ପ୍ରାର୍ଥୀମାନଙ୍କୁ ରାଙ୍କ୍ କରାଯାଏ (TestGorilla).

ଫଳାଫଳଗୁଡ଼ିକୁ ପ୍ରାୟତଃ ଧାଡ଼ି ଅନୁସାରେ ଯାଞ୍ଚ କରାଯାଏ। ତେଣୁ, ପ୍ରାୟ ସଠିକ୍ ଥିବା ଏକ query, ଯେପରିକି ଅର୍ଡର ନଥିବା ଗ୍ରାହକଙ୍କୁ ବାଦ୍ ଦେଉଥିବା query, କୌଣସି ଉତ୍ତର ନଦେବା ସହ ସମାନ ସ୍କୋର ପାଇପାରେ।

ଆମର ଅଭ୍ୟାସ ସ୍କୋର ହେଉଛି ଆମର ନିଜ ପ୍ରଶ୍ନଗୁଡ଼ିକ ମଧ୍ୟରୁ ଆପଣ କେତୋଟିର ସଠିକ୍ ଉତ୍ତର ଦେଇଛନ୍ତି, ତାହାର ବିଭାଗ ଅନୁସାରେ ବିବରଣୀ। ଏହା ଆପଣଙ୍କୁ କେଉଁଠି ଅଧିକ ଧ୍ୟାନ ଦେବାକୁ ପଡ଼ିବ ତାହା ଦେଖାଏ। ଏହା ଏକ ଅଭ୍ୟାସ ସ୍କୋର: ଏହା କୌଣସି ନିଯୁକ୍ତିଦାତା କିମ୍ବା ପ୍ଲାଟଫର୍ମର ପରୀକ୍ଷାର ସ୍କୋର ନୁହେଁ ଏବଂ ଆପଣ ଉତ୍ତୀର୍ଣ୍ଣ ହେବେ କି ନାହିଁ ତାହାର ପୂର୍ବାନୁମାନ କରେନାହିଁ।

ସାଧାରଣ ଭୁଲ

• = ବ୍ୟବହାର କରି NULL ସହ ତୁଳନା। IS NULL ଏବଂ IS NOT NULL ବ୍ୟବହାର କରନ୍ତୁ। = NULL ଥିବା ଯେକୌଣସି ତୁଳନାର ଫଳ ଅଜଣା ହୁଏ, ତେଣୁ ସେହି row ଫିଲ୍ଟର୍ ହୋଇ ବାଦ ପଡ଼େ।
• LEFT JOIN ରେ WHERE ଦ୍ୱାରା ଫିଲ୍ଟର୍ କରିବା। ଡାହାଣ ପଟର table ର column ଉପରେ ଲାଗୁ ହୋଇଥିବା ଶର୍ତ୍ତ, ମେଳ ନଖାଉଥିବା row ଗୁଡ଼ିକୁ ବାଦ ଦିଏ। ସେଗୁଡ଼ିକୁ ରଖିବାକୁ ଚାହୁଁଥିଲେ, ସେହି ଶର୍ତ୍ତକୁ ON clause ରେ ରଖନ୍ତୁ।
• ମୋଟ ପାଇଁ WHERE ବ୍ୟବହାର କରିବା। Aggregate ଗୁଡ଼ିକ GROUP BY ପରେ HAVING ରେ ରହିବା ଉଚିତ।
• ଗ୍ରୁପ୍ ନକରିଥିବା column ଚୟନ କରିବା। Standard SQL ରେ ଚୟନ କରାଯାଇଥିବା ପ୍ରତ୍ୟେକ column କୁ ଗ୍ରୁପ୍ କରିବା କିମ୍ବା aggregate କରିବା ଆବଶ୍ୟକ। କିଛି database ରେ query ଚାଲିଯାଏ ଏବଂ ସେଗୁଡ଼ିକ ଆପଣଙ୍କ ପାଇଁ ଗୋଟିଏ ମୂଲ୍ୟ ବାଛିଦିଅନ୍ତି, ଯାହା ଭୁଲଟିକୁ ଲୁଚାଇ ଦିଏ।
• ନକଲ୍ ଭୁଲିଯିବା। Join ଦ୍ୱାରା row ପୁନରାବୃତ୍ତି ହୋଇପାରେ, ଯାହା SUM ଏବଂ COUNT କୁ ବଢ଼ାଇଦିଏ। ଗୋଟିଏ ପଟର ପ୍ରତ୍ୟେକ row ଅନ୍ୟ ପଟର ଏକାଧିକ row ସହ ମେଳ ଖାଇପାରିବ କି ନାହିଁ, ତାହା ଭାବନ୍ତୁ।
• ଗୋଟିଏ database ର shortcut ଉପରେ ନିର୍ଭର କରିବା। ବିଭିନ୍ନ database ରେ କିଛି function ଏବଂ limit syntax ଅଲଗା ହୋଇପାରେ। Standard form ଶିଖନ୍ତୁ ଏବଂ ଆପଣଙ୍କ test ରେ କେଉଁ database ବ୍ୟବହାର ହେଉଛି, ତାହା ଯାଞ୍ଚ କରନ୍ତୁ।