SQL ഫോർമാറ്റർ & വാലിഡേറ്റർ

SQL ഫോർമാറ്റിംഗ് എന്തുകൊണ്ട് പ്രധാനമാണ്

ഒരു ഡാറ്റാബേസ് പ്രൊജക്റ്റ് കൈമാറിക്കിട്ടിയിട്ടുണ്ടോ, അതിലെ SQL കുറിപ്പ് കണ്ണടച്ചിട്ട് ടൈപ്പ് ചെയ്തതുപോലെ കാണുന്നുവോ? നിങ്ങൾ മാത്രമല്ല. മോശമായി ഫോർമാറ്റ് ചെയ്ത SQL ഡാറ്റാബേസ് വികസനത്തിൽ ബഗുകളുടെയും സമയം കളയുന്നതിന്റെയും ഏറ്റവും സാധാരണ കാരണങ്ങളിൽ ഒന്നാണ്.

ഈ SQL ഫോർമാറ്റർ കൂടിയുള്ള വിലയിരുത്തൽ നിങ്ങൾക്ക് ക്രിമിനൽ ക്വറികൾ യാന്ത്രികമായി വൃത്തിയാക്കാൻ സഹായിക്കുന്നു. നിങ്ങളുടെ SQL പേസ്റ്റ് ചെയ്യുക, അത് ഉടനെ ശരിയായ ഇൻഡന്റേഷൻ പ്രയോഗിക്കുകയും കീവേഡുകൾ മുതലക്ഷരം വലുതാക്കുകയും സിന്റാക്സ് പിഴവുകൾ പരിശോധിക്കുകയും ചെയ്യുന്നു—ഒരു സെർവറിലേക്ക് ഡാറ്റ അയയ്ക്കാതെ നിങ്ങളുടെ ബ്രൗസറിൽ തന്നെ. സാധാരണ 10-15 മിനിറ്റ് മാനുവൽ ഫോർമാറ്റിംഗ് ചെയ്യുന്നത് ഇവിടെ സെക്കൻഡുകൾക്കുള്ളിൽ നടക്കുന്നു.

ഡാറ്റാബേസ് ടീമുകളുമായി പ്രവർത്തിക്കുന്ന എന്റെ അനുഭവത്തിൽ, ഏറ്റവും വലിയ സമയ സമ്പാദനം ഫോർമാറ്റിംഗ് മാത്രമല്ല—ഉൽപാദനത്തിൽ എത്തുന്നതിനുമുൻപ് പിഴവുകൾ കണ്ടെത്തുന്നതാണ്. ഒരു തെറ്റായി വച്ച പരന്തസിസ് അല്ലെങ്കിൽ അടയ്ക്കാത്ത കോട്ട് ഡീബഗ് ചെയ്യുന്നതിൽ മണിക്കൂറുകൾ കളയാൻ കാരണമാകും. ഈ ഉപകരണം ഡാറ്റാബേസിനെതിരെ ഏതെങ്കിലും കൽപ്പന നടപ്പിലാക്കുന്നതിനുമുൻപ് ഉടനെ ഈ പ്രശ്നങ്ങൾ കണ്ടെത്തുന്നു.

SQL ഫോർമാറ്റർ ഉപയോഗിക്കുന്ന വിധം

ഇന്റർഫേസ് നിർമ്മിക്കപ്പെട്ടിരിക്കുന്നത് മിനിമൽ രീതിയിൽ—വളരെ എളുപ്പം പേസ്റ്റ് ചെയ്യുക:

SQL നിങ്ങളുടെ ഇൻപുട്ട് ബോക്സിൽ പേസ്റ്റ് ചെയ്യുക (അല്ലെങ്കിൽ സ്ക്രാച്ചിൽ നിന്ന് എഴുതുകയാണെങ്കിൽ നേരിട്ട് ടൈപ്പ് ചെയ്യുക)
നിങ്ങൾ ടൈപ്പ് ചെയ്യുമ്പോൾ സ്വയമേവ ഫോർമാറ്റ് ചെയ്യുക—ക്ലിക്ക് ചെയ്യേണ്ട ബട്ടണുകൾ ഇല്ല, കോൺഫിഗർ ചെയ്യേണ്ട സെറ്റിംഗുകൾ ഇല്ല
വാലിഡേഷൻ പിഴവുകൾ പരിശോധിക്കുക ഫോർമാറ്റ് ചെയ്ത ഔട്ട്പുട്ടിൽ കീഴിൽ എന്തെങ്കിലും പ്രത്യക്ഷപ്പെട്ടാൽ
ഫോർമാറ്റ് ചെയ്ത SQL കോപ്പി ചെയ്യുക ഒരു ക്ലിക്കിൽ നിങ്ങളുടെ IDE, പ്രമാണീകരണം, അല്ലെങ്കിൽ ഡാറ്റാബേസ് ഉപകരണത്തിൽ ഉപയോഗിക്കുവാൻ

ബ്രൗസർ ഉള്ള ഏതൊരു ഉപകരണത്തിലും പ്രവർത്തിക്കുന്നു. ഫോർമാറ്റിംഗ് നടക്കുന്നത് പൂർണ്ണമായും ക്ലൈന്റ്-സൈഡിൽ, അതിനാൽ നിങ്ങളുടെ ക്വറികൾ ഒരിക്കലും നിങ്ങളുടെ യന്ത്രത്തിൽ നിന്ന് പുറത്തുപോകുന്നില്ല—ഉൽപ്പാദന ഡാറ്റാബേസ് സ്ട്രക്ചേഴ്സ് അല്ലെങ്കിൽ സംവേദനീയ സ്കീമകൾ പ്രവർത്തിക്കുമ്പോൾ പ്രധാനം.

SQL ഫോർമാറ്റർ എന്ത് ചെയ്യുന്നു

കീവേഡ് മുതലക്ഷരം വലുതാക്കൽ

എല്ലാ SQL കീവേഡുകളും സ്വയമേവ മുതലക്ഷരം വലുതാക്കപ്പെടുന്നു—SELECT, FROM, WHERE, JOIN, മുതലായവ. ഇത് മിക്ക ഡാറ്റാബേസ് സംഘങ്ങളും പിന്തുടരുന്ന രീതിയാണ്, കൂടാതെ കീവേഡുകളെ നിങ്ങളുടെ പട്ടിക മുതൽ നാമങ്ങളിൽ നിന്ന് വ്യക്തമായി വേർതിരിക്കുന്നു. ഒരു സങ്കീർണ്ണ ക്വറിയിലൂടെ സ്കാൻ ചെയ്യുമ്പോൾ, ഈ വിഷുവൽ വേർതിരിവ് ക്വറി സ്ട്രക്ചർ തിരിച്ചറിയാൻ സഹായിക്കുന്നു.

സ്മാർട്ട് ഇൻഡന്റേഷൻ

ഫോർമാറ്റർ നിങ്ങളുടെ SQL-നെ യാദൃശ്ചിക വരികൾ ഇടുന്നതിനുപകരം താർക്കിക വിഹംഗമനത്തിന്റെ അടിസ്ഥാനത്തിൽ സ്ട്രക്ചർ ചെയ്യുന്നു. SELECT പോലുള്ള മുഖ്യ ക്ലോസുകൾ ഇടത്തെ മാർജിനിൽ തുടങ്ങുന്നു. JOIN ക്ലോസുകൾ FROM-ന്റെ കീഴിൽ ഇൻഡന്റ് ചെയ്യപ്പെടുന്നു, അവ പട്ടിക തിരഞ്ഞെടുപ്പിന്റെ ഭാഗമാണെന്ന് കാണിക്കുന്നു. സബ്ക്വറികൾ അധിക ഇൻഡന്റേഷൻ തലങ്ങൾ നേടുന്നു, ഏകീകൃത തലത്തിലുള്ള തർക്കം വ്യക്തമാക്കുന്നു.

പ്രാക്ടിസിൽ സംഭവിക്കുന്നത്: നിങ്ങൾക്ക് മൾട്ടിപ്പിൾ ജോയിൻസ് മുതൽ സബ്ക്വറികൾ വരെയുള്ള ഒരു ക്വറി ഉണ്ടെങ്കിൽ, ശരിയായ ഇൻഡന്റേഷൻ ഓരോ വാക്കും വായിക്കാതെ ക്വറി സ്ട്രക്ചർ കാണാൻ അനുവദിക്കുന്നു. ഒരു ജോയിൻ അവസാനിക്കുന്ന സ്ഥലവും മറ്റൊന്ന് തുടങ്ങുന്ന സ്ഥലവും, അല്ലെങ്കിൽ നിങ്ങളുടെ SELECT പട്ടികയിൽ ഒരു സബ്ക്വറി ഉപയോഗിക്കുന്ന സ്ഥലവും നിങ്ങൾക്ക് ഉടനടി കണ്ടെത്താം.

താർക്കിക വരി വിഭജനം

വരി വിഭജനങ്ങൾ വായനക്ഷമത സഹായിക്കുന്ന സ്ഥലത്ത് മാത്രം വരുന്നു, ഏതു സ്ഥലത്തും അല്ല. ഓരോ മുഖ്യ ക്ലോസിനും അതിന്റെ സ്വന്തം വരി ലഭിക്കുന്നു. കോമ്മ വേർതിരിച്ച പട്ടികകളിലെ (SELECT-ലെ കോളം നാമങ്ങൾ പോലെ) ഓരോ ഇനവും ശരിയായ ഇൻഡന്റേഷനോടെ അവരുടെ സ്വന്തം വരി നേടുന്നു. സബ്ക്വറികൾ വിഷുവൽ വേർതിരിവ് നേടുന്നു. CASE സ്റ്റേറ്റ്മെന്റുകൾ വ്യക്തതയ്ക്കായി WHEN, THEN, ELSE-ൽ വിഭജിക്കപ്പെടുന്നു.

സ്പേസിംഗ് വ്യവസായത്തിൽ ഉപയോഗിക്കുന്ന SQL സ്റ്റൈൽ ഗൈഡ് നിബന്ധനകൾ പിന്തുടരുന്നു, അതിനർത്ഥം നിങ്ങളുടെ ഫോർമാറ്റ് ചെയ്ത SQL മറ്റ് ഡവലപ്പർമാർക്ക് പരിചിതമായി തോന്നും.

SQL വാലിഡേഷൻ: എന്താണ് പരിശോധിക്കുന്നത്

വാലിഡേറ്റർ SQL എഴുതുമ്പോൾ സാധാരണ കടന്നുപോകുന്ന പിഴവുകൾ കണ്ടെത്തുന്നു. ഇത് നിങ്ങളുടെ ഡാറ്റാബേസിന്റെ ക്വറി വിശ്ലേഷകനെ മാറ്റിനിർത്തുകയല്ല, പക്ഷേ ക്വറി പാലിക്കുന്നതിനു മുൻപ് സാധാരണ പിഴവുകൾ കണ്ടെത്തുന്നു.

സ്ട്രക്ചറൽ പിഴവുകൾ

അസമവാക്യ മൊഴിവിടലുകൾ സങ്കീർണ്ണ ക്വറികളിൽ വളരെ സാധാരണമാണ്. വാലിഡേറ്റർ തുറന്ന മൊഴിവിടലുകളുടെയും അടച്ച മൊഴിവിടലുകളുടെയും എണ്ണം പരിശോധിച്ച് വ്യത്യാസങ്ങൾ ഉടൻ കണ്ടെത്തുന്നു. 200 വരി ക്വറിയിൽ ഒരു മൊഴിവിടൽ കുറവ് കാരണം ഉണ്ടായ ഉൽപ്പാദന സംഭവങ്ങൾ ഞാൻ കണ്ടിട്ടുണ്ട്—ഇത് അവയെ നേരത്തെ കണ്ടെത്തുന്നു.

അവസാനിക്കാത്ത സ്ട്രിംഗ് ലിറ്ററലുകൾ സ്ട്രിംഗ് മൂല്യത്തിൽ അവസാന ഉദ്ധരണി മറന്നാൽ സംഭവിക്കുന്നു. നിങ്ങളുടെ ഡാറ്റാബേസ് ഇവയെ ഉടൻ നിരസിക്കും, പക്ഷേ ഇവിടെ കണ്ടെത്തുന്നത് ഒരു വഴിത്തിരിവ് സമയം ലാഭിക്കുന്നു.

ക്ലോസ് ക്രമത്തിലുള്ള പിഴവുകൾ ക്ലോസുകൾ ശരിയായ ക്രമത്തിൽ വരാത്തപ്പോൾ കണ്ടെത്തുന്നു. ഉദാഹരണത്തിന്, HAVING-ന് മുൻപ് GROUP BY വന്നാൽ, അല്ലെങ്കിൽ WHERE-ന് ശേഷം GROUP BY വന്നാൽ, വാലിഡേറ്റർ നിങ്ങളെ അറിയിക്കുന്നു. ഇത് ISO/IEC 9075 SQL മാനദണ്ഡം-ൽ നിർവചിച്ചിരിക്കുന്ന SQL സ്റ്റാൻഡേർഡ് സിന്റാക്സ് നിയമങ്ങൾ പിന്തുടരുന്നു.

ലോജിക്കൽ പിഴവുകൾ

ON നിബന്ധനകളില്ലാത്ത JOIN ക്ലോസുകൾ അനിഷ്ടമായ ക്രോസ് ജോയിനുകൾ സൃഷ്ടിക്കുന്നു, വളരെ കൂടുതൽ വരികൾ തിരിച്ചുവിടുന്നു. ഒരു സാധാരണ സ്ഥിതി: നിങ്ങൾ ഒരു ക്വറിയിൽ മൂന്നാമത്തെയോ നാലാമത്തെയോ പട്ടിക ചേർക്കുമ്പോൾ ON ക്ലോസ് മറന്നുപോകുന്നു. ഈ പരിശോധന ഇല്ലെങ്കിൽ, നിങ്ങൾ ഫലങ്ങളിൽ ആയിരക്കണക്കിന് പകർപ്പുകൾ കാണുന്നത് വരെ ശ്രദ്ധിക്കില്ല.

GROUP BY ഇല്ലാത്ത HAVING sebhധുകൂടുതൽ ഡാറ്റാബേസുകളിൽ സാങ്കേതികമായി അസാധുവാണ്. HAVING ക്ലോസ് ഗ്രൂപ്പുചെയ്ത ഫലങ്ങൾ അരിച്ചെടുക്കുന്നതിനാൽ, ഇത് പ്രവർത്തിക്കുന്നതിന് GROUP BY ആവശ്യമാണ്. വാലിഡേറ്റർ ഈ ലോജിക്കൽ വ്യത്യാസം കണ്ടെത്തുന്നു.

അപൂർണ്ണ WHERE നിബന്ധനകൾ നിബന്ധന തുടങ്ങുമ്പോൾ അവസാനിപ്പിക്കാതിരിക്കുന്നതിൽ സംഭവിക്കുന്നു—WHERE status = പോലെ യാതൊരു മൂല്യവുമില്ലാതെ. ക്വറികൾ സംശോധിക്കുമ്പോൾ ഇവ കാണാൻ കഴിയാതെ പോകുന്നു.

ഇത് കണ്ടെത്തില്ല

ഈ വാലിഡേറ്റർ സിന്റാക്സിലും സ്ട്രക്ചറിലും കേന്ദ്രീകരിക്കുന്നു, ഡാറ്റാബേസ് സ്കീമയിൽ അല്ല. ഇത് അറിയില്ല:

നിങ്ങളുടെ ഡാറ്റാബേസിൽ നിങ്ങളുടെ പട്ടിക അല്ലെങ്കിൽ നിരകളുടെ പേരുകൾ നിലവിലുണ്ടോ
നിങ്ങൾ യോഗ്യമായ ഡാറ്റ തരങ്ങളിൽ ചേർക്കുന്നുണ്ടോ
നിങ്ങളുടെ ക്വറി നന്നായി പ്രവർത്തിക്കുകയോ അനുകൂലനം ചെയ്യുകയോ ചെയ്യുന്നുണ്ടോ
നിങ്ങൾ ക്വറി ചെയ്യുന്ന പട്ടികകൾ ആക്സസ്സ് ചെയ്യാൻ അനുമതിയുണ്ടോ

ഇതിനെ ഡാറ്റാബേസിലേക്ക് ക്വറി അയയ്ക്കുന്നതിനു മുൻപ് ഒരു ആദ്യ പരിശോധനയായി കരുതുക.

ഫോർമാറ്റിംഗ് നിയമങ്ങൾ ഈ ഉപകരണം പ്രയോഗിക്കുന്നു

ഫോർമാറ്റർ SQL സ്റ്റൈൽ മാർഗ്ഗനിർദ്ദേശ കൺവെൻഷൻസിന് അനുസൃതമായി സ്ഥിരമായ നിയമങ്ങൾ പ്രയോഗിക്കുന്നു, അത് മിക്ക ഡാറ്റാബേസ് ടീമുകളും പിന്തുടരുന്നു.

കീവേഡുകൾ മുതലക്ഷരം വലുതാക്കുന്നു

ഓരോ SQL കീവേഡും മുതലക്ഷരം വലുതാക്കുന്നു: SELECT, INSERT, UPDATE, DELETE, CREATE, ALTER, DROP. ഇതിൽ ക്ലോസുകൾ (FROM, WHERE, GROUP BY, HAVING, ORDER BY), ജോയിൻ തരങ്ങൾ (JOIN, INNER JOIN, LEFT JOIN), ഓപ്പറേറ്റർമാർ (AND, OR, NOT, IN, BETWEEN, LIKE), സാധാരണ ഫംഗ്ഷനുകൾ (COUNT, SUM, AVG, CASE, WHEN) എന്നിവ ഉൾപ്പെടുന്നു.

എന്തുകൊണ്ട് മുതലക്ഷരം വലുതാക്കുന്നു? ഇത് SQL യുടെ ഭാഷാ മൂലകങ്ങൾക്കും നിങ്ങളുടെ ഡാറ്റാബേസ്-പ്രത്യേക പേരുകൾക്കും (പട്ടികകൾ, കോളങ്ങൾ, അലിയാസുകൾ) ദृശ്യമായ വ്യത്യാസം സൃഷ്ടിക്കുന്നു. ഒരു ക്വറിയെ സ്കാൻ ചെയ്യുമ്പോൾ, നിങ്ങളുടെ കണ്ണ് ഉടൻ തന്നെ സ്ട്രക്ചർ കണ്ടെത്തുന്നു.

ഓരോ തലത്തിനും രണ്ട് സ്പേസ് ഇൻഡന്റേഷൻ

SELECT പോലുള്ള മുഖ്യ ക്ലോസുകൾ ഇടത്തെ മാർജിനിൽ തുടങ്ങുന്നു. JOIN ക്ലോസുകൾ FROM-ന് കീഴിൽ രണ്ട് സ്പേസ് ഇൻഡന്റ് ചെയ്യുന്നു, അവ പട്ടിക തിരഞ്ഞെടുപ്പിന്റെ ഭാഗമാണെന്ന് കാണിക്കുന്നു. സബ്ക്വറികൾ ഓരോ നെസ്റ്റിംഗ് തലത്തിനും മറ്റ് രണ്ട് സ്പേസ് ഇൻഡന്റ് ചെയ്യുന്നു. ഇത് ലോജിക്കൽ സ്ട്രക്ചറിനൊപ്പം ഒരു ദൃശ്യ വ്യവസ്ഥ സൃഷ്ടിക്കുന്നു.

കോമ്മ വിഭജിച്ച പട്ടികകൾ (ഉദാഹരണത്തിന് SELECT-ലെ കോളം പേരുകൾ) ഓരോന്നും സ്ഥിരമായ ഇൻഡന്റേഷനുള്ള വരിയിൽ വരുന്നു. നിങ്ങളുടെ SELECT പട്ടികയിൽ 15 കോളങ്ങൾ ഉണ്ടെങ്കിൽ, ഇത് പ്രത്യേക കോളങ്ങൾ കണ്ടെത്തുന്നതിന് എളുപ്പമാക്കുന്നു.

WHERE ക്ലോസുകളിലെ വ്യവസ്ഥകൾ വെർട്ടിക്കലായി അനുരേഖീകരിക്കുന്നു. നിങ്ങൾക്ക് മല്ടിപ്പിൾ AND അല്ലെങ്കിൽ OR വ്യവസ്ഥകൾ ഉണ്ടെങ്കിൽ, അനുരേഖീകരണം ലോജിക് സ്ട്രക്ചർ ഉടൻ തന്നെ വ്യക്തമാക്കുന്നു.

മുൻപും ശേഷവും: വ്യത്യാസം കാണുക

മുൻപ് ഫോർമാറ്റിംഗ്:

1select u.id, u.name, o.order_date from users u join orders o on u.id = o.user_id where o.status = "completed" group by u.id order by u.name;
2

ഫോർമാറ്റിംഗ് ശേഷം:

1SELECT
2  u.id,
3  u.name,
4  o.order_date
5FROM users u
6  JOIN orders o ON u.id = o.user_id
7WHERE
8  o.status = "completed"
9GROUP BY
10  u.id
11ORDER BY
12  u.name;
13

സാധുതാ നിയമങ്ങൾ: എന്തൊക്കെ ഫ്ലാഗ് ചെയ്യപ്പെടുന്നു

വാലിഡേറ്റർ സ്ട്രക്ചറൽ അഖണ്ഡത്വവും അടിസ്ഥാന താർക്കിക സ്ഥിരതയും പരിശോധിക്കുന്നു. അത് എന്താണ് പരിശോധിക്കുന്നത്:

സ്ട്രക്ചറൽ പരിശോധനകൾ

സന്തുലിത മൊഴിവിടുകൾ: തുറന്ന കൊഞ്ഞിൽ മൊഴിവിടുകളും അടച്ച കൊഞ്ഞിൽ മൊഴിവിടുകളും പൊരുത്തപ്പെടണം. വ്യൂഹ ഉൾവിഭാഗങ്ങൾക്ക് പലതവണ മൊഴിവിടുകളുടെ മല്ടിപ്പിൾ തലങ്ങൾ ഉണ്ടാകും, അവയെ തെറ്റായി കണക്കാക്കുന്നത് ഏറ്റവും സാധാരണ SQL പിഴവുകളിൽ ഒന്നാണ്. വാലിഡേറ്റർ അവയെ നിങ്ങൾക്കുവേണ്ടി കണക്കാക്കുന്നു.

ശരിയായി അടച്ച സ്ട്രിംഗുകൾ: ഓരോ തുറന്ന കോട്ടേഷൻ (സിംഗിൾ അല്ലെങ്കിൽ ഡബിൾ) ക്ക് ഒരു അടച്ച കോട്ടേഷൻ വേണം. വ്യക്തമായി കാണുന്നുണ്ടെങ്കിലും, നിങ്ങൾ മൾട്ടിപ്പിൾ സ്ട്രിംഗ് ലിറ്ററലുകളുള്ള ഒരു സങ്കീർണ്ണ ക്വറിയെഴുതുമ്പോൾ, ഒന്ന് മിസ്സ് ചെയ്യുക എളുപ്പമാണ്.

ശരിയായ ക്ലോസ് ക്രമം: SQL-ന് പ്രത്യേക ക്രമീകരണ ആവശ്യകതകൾ ഉണ്ട്. SELECT FROM-നു മുൻപ്, WHERE FROM-നു മുൻപ്, GROUP BY WHERE-നു മുൻപ്, HAVING GROUP BY-നു മുൻപ്, ORDER BY HAVING-നു മുൻപ് വരണം. അവയെ ക്രമരഹിതമായി വയ്ക്കുന്നത് ഉടനടി സിന്റാക്സ് പിഴവുകൾ സൃഷ്ടിക്കുന്നു. SQL സ്റ്റാൻഡേർഡിന്റെ അടിസ്ഥാനത്തിൽ വാലിഡേറ്റർ ഈ ക്രമം പരിശോധിക്കുന്നു.

താർക്കിക സ്ഥിരതാ പരിശോധനകൾ

ON കണ്ടീഷനുള്ള JOIN: ഓരോ JOIN-ഉം പട്ടികകൾ എങ്ങനെ ബന്ധപ്പെട്ടിരിക്കുന്നു എന്ന് വ്യക്തമാക്കാൻ ഒരു ON അല്ലെങ്കിൽ USING ക്ലോസ് വേണം. അതില്ലാതെ, നിങ്ങൾ ക്രോസ് ജോയിൻ നേടും—ഒരു പട്ടികയിലെ ഓരോ വരയും മറ്റൊരു പട്ടികയിലെ ഓരോ വരയുമായി കൂട്ടിച്ചേർക്കപ്പെടുന്നു. അത് വളരെ അപൂർവ്വമായി വാഞ്ഛിക്കുന്നതാണ് കൂടാതെ സാധാരണഗതിയിൽ ഒരു നഷ്ടപ്പെട്ട ON ക്ലോസിനെ സൂചിപ്പിക്കുന്നു.

പൂർണ്ണ WHERE കണ്ടീഷനുകൾ: WHERE ക്ലോസിന് പൂർണ്ണ പ്രഡിക്കേറ്റുകൾ വേണം. മൂല്യമില്ലാതെ WHERE status = അപൂർണ്ണവും അസാധുവുമാണ്. വാലിഡേറ്റർ ഈ ഭാഗിക കണ്ടീഷനുകൾ ഫ്ലാഗ് ചെയ്യുന്നു.

HAVING-ന് GROUP BY ആവശ്യം: HAVING ക്ലോസ് ഗ്രൂപ്പ് ചെയ്ത ഫലങ്ങളെ ഫിൽട്ടർ ചെയ്യുന്നതിനാൽ, GROUP BY ഉള്ളപ്പോൾ മാത്രമേ അർഥമുള്ളൂ. GROUP BY ഇല്ലാതെ HAVING ഉപയോഗിക്കുന്നത് ഒരു താർക്കിക പിഴവാണ്, മിക്ക ഡാറ്റാബേസുകളും നിരാകരിക്കുന്നു.

GROUP BY കൂട്ടിച്ചേർക്കൽ നിയമങ്ങൾ: COUNT() അല്ലെങ്കിൽ SUM() പോലുള്ള കൂട്ടിച്ചേർക്കൽ ഫംഗ്ഷനുകൾ ഉപയോഗിക്കുമ്പോൾ, SELECT പട്ടികയിലെ കൂട്ടിച്ചേർക്കാത്ത കോളങ്ങൾ GROUP BY-ൽ പ്രത്യക്ഷപ്പെടണം. ഇത് ഒരു അടിസ്ഥാന SQL ആവശ്യകതയാണ്, വാലിഡേറ്റർ പരിശോധിക്കുന്നത്.

പൊതുവായ പിഴവുകൾ കണ്ടെത്തിയ ഉദാഹരണം

വാലിഡേറ്റർ ഫ്ലാഗ് ചെയ്യുന്ന മൾട്ടിപ്പിൾ പ്രശ്നങ്ങളുള്ള SQL:

1SELECT user_id, COUNT(*) FROM orders
2JOIN users
3WHERE status =
4GROUP BY
5HAVING count > 10;
6

കണ്ടെത്തിയ പ്രശ്നങ്ങൾ:

JOIN users-ൽ ON കണ്ടീഷൻ നഷ്ടപ്പെട്ടു (ക്രോസ് ജോയിൻ സൃഷ്ടിക്കും)
WHERE status = അപൂർണ്ണം (തുല്യതാ മൂല്യം ഇല്ല)
ശൂന്യ GROUP BY ക്ലോസ് (കോളങ്ങൾ വ്യക്തമാക്കിയിട്ടില്ല)
HAVING count > 10 അനിർവചിത കോളത്തെ സൂചിപ്പിക്കുന്നു

SQL ഫോർമാറ്റർ ഉപയോഗിക്കേണ്ട സമയം

കോഡ് പരിശോധനയിൽ

50 വരി SQL ക്വറി ഒരു വരിയിൽ എഴുതിയിരിക്കുന്നത് പരിശോധിക്കുന്നത് എത്ര കഠിനമാണ്! ക്വറികൾ കോഡ് പരിശോധനയ്ക്ക് സമർപ്പിക്കുന്നതിന് മുൻപ്, അവയെ ഫോർമാറ്റർ വഴി കടത്തുക. നിങ്ങളുടെ പരിശോധകർ നന്ദി പറയും, കൂടാതെ അവർക്ക് സ്ട്രക്ചർ വ്യാഖ്യാനിക്കുന്നതിനുപകരം ലോജിക്കിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കാൻ കഴിയും.

ഡാറ്റാബേസ് മാറ്റങ്ങളുള്ള പുൾ അഭ്യർഥനകളിൽ, സംഭാവകരോട് അവരുടെ SQL ആദ്യം ഫോർമാറ്റ് ചെയ്യാൻ ആവശ്യപ്പെടുക. സ്ട്രക്ചർ സ്ഥിരമാകുമ്പോൾ ലോജിക് പിഴവുകൾ കണ്ടെത്തൽ വളരെ എളുപ്പമാകും.

ഉൽപ്പാദന പ്രശ്നങ്ങൾ ഡീബഗ് ചെയ്യുമ്പോൾ

ഉൽപ്പാദനത്തിൽ പരാജയപ്പെട്ട ഒരു ക്വറി പരിഹരിക്കുമ്പോൾ, അതിനെ ശരിയായി ഫോർമാറ്റ് ചെയ്യുന്നത് സ്ട്രക്ചർ വ്യക്തമായി കാണാൻ സഹായിക്കും. ഒരു കാണാതെ പോയ ജോയിൻ കണ്ടീഷൻ, തെറ്റായ WHERE ക്ലോസ് ഗ്രൂപ്പിംഗ്, അല്ലെങ്കിൽ തെറ്റായ സ്ഥാനത്തുള്ള ഒരു സബ്ക്വറി - ഇവയിൽ പലതും ക്വറി ശരിയായി ഫോർമാറ്റ് ചെയ്യുമ്പോൾ വ്യക്തമാകും.

നിങ്ങളുടെ ലോഗുകളിൽ നിന്ന് ക്വറി കോപ്പി ചെയ്ത്, ഇവിടെ പേസ്റ്റ് ചെയ്യുക, നിങ്ങൾക്ക് ഉടനെ സ്ട്രക്ചറൽ പ്രശ്നങ്ങൾ കാണാൻ കഴിയും.

ജനറേറ്റ് ചെയ്ത SQL വർക്ക് ചെയ്യുമ്പോൾ

ഹൈബർനേറ്റ്, എന്റിറ്റി ഫ്രെയിംവർക്ക്, അല്ലെങ്കിൽ SQLAlchemy പോലുള്ള ORM (ഒബ്ജക്റ്റ്-റിലേഷണൽ മാപ്പർ) സ്വയമേവ SQL ജനറേറ്റ് ചെയ്യുന്നു. ചിലപ്പോൾ അവർ യഥാർഥത്തിൽ ഏത് ക്വറി ഉൽപ്പാദിപ്പിക്കുന്നു എന്ന് കാണേണ്ടതുണ്ട്. ജനറേറ്റ് ചെയ്ത SQL പതിവായി ഒരു നീണ്ട വരിയിൽ യാതൊരു ഫോർമാറ്റിംഗുമില്ലാതെ വരും. ഈ ഉപകരണം ORM-ജനറേറ്റ് ക്വറികളെ വായിക്കാവുന്ന രൂപത്തിലാക്കുകയും അവയെ മനസ്സിലാക്കി അനുകൂലീകരിക്കാൻ സഹായിക്കുകയും ചെയ്യുന്നു.

SQL പഠിക്കുകയും പഠിപ്പിക്കുകയും ചെയ്യുമ്പോൾ

നിങ്ങൾ SQL പഠിക്കുകയോ പഠിപ്പിക്കുകയോ ചെയ്യുന്നുവെങ്കിൽ, ഈ ഫോർമാറ്റർ ശരിയായ ക്വറി സ്ട്രക്ചർ മനസ്സിലാക്കാൻ സഹായിക്കും. ഒരു പ്രവർത്തിക്കുന്ന ക്വറി പേസ്റ്റ് ചെയ്യുമ്പോൾ അത് ഫോർമാറ്റ് ചെയ്യപ്പെടുന്ന രീതി കാണുമ്പോൾ, നിങ്ങൾ കൺവെൻഷനുകൾ പഠിക്കുന്നു. ഒരു പൊട്ടിയ ക്വറി പേസ്റ്റ് ചെയ്യുമ്പോൾ വലിഡേഷൻ പിഴവുകൾ കാണുമ്പോൾ, അത് എന്തുകൊണ്ട് പ്രവർത്തിക്കുന്നില്ല എന്ന് മനസ്സിലാക്കാൻ കഴിയും.

ഡാറ്റാബേസ് സിസ്റ്റങ്ങൾ മൈഗ്രേറ്റ് ചെയ്യുമ്പോൾ

വ്യത്യസ്ത ഡാറ്റാബേസുകൾ (PostgreSQL, MySQL, SQL സെർവർ) ചെറിയ വ്യത്യസ്ത SQL ഭാഷകൾ ഉപയോഗിക്കുന്നു. സിസ്റ്റങ്ങൾ തമ്മിൽ ക്വറികൾ മൈഗ്രേറ്റ് ചെയ്യുമ്പോൾ, ശരിയായ ഫോർമാറ്റിംഗ് ഭാഷാ-നിർദ്ദിഷ്ട സിന്റാക്സ് കണ്ടെത്താൻ സഹായിക്കും. ഫോർമാറ്റർ മിക്ക പ്രധാന ഡാറ്റാബേസുകളിലും പ്രവർത്തിക്കുന്ന സ്റ്റാൻഡേർഡ് SQL കൺവെൻഷനുകൾ പിന്തുടരുന്നു.

ഈ SQL ഫോർമാറ്റർക്കുള്ള ബദൽ സംവിധാനങ്ങൾ

ഡാറ്റാബേസ് നിർദ്ദിഷ്ട IDE കൾ

DataGrip, SQL സർവർ മാനേജ്മെൻറ് സ്റ്റുഡിയോ, അല്ലെങ്കിൽ MySQL വർക്ക്ബെഞ്ച് പോലുള്ള ഉപകരണങ്ങൾക്ക് അന്തർനിർമ്മിത ഫോർമാറ്ററുകൾ ഉണ്ട്. അവ ശക്തവും നേരിട്ട് നിങ്ങളുടെ ഡാറ്റാബേസ് കണക്ഷനുമായി സംയോജിക്കുന്നവയുമാണ്.

വ്യത്യാസം: അവ ഇൻസ്റ്റളേഷനും സജ്ജീകരണവും ആവശ്യപ്പെടുന്നു. DataGrip വ്യക്തിഗത ഉപയോക്താക്കൾക്ക് വാർഷിക $199 വിലയിൽ വരുന്നു. SSMS സൗജന്യമാണെങ്കിലും വിൻഡോസ് മാത്രം. നിർബന്ധമായും ഏതെങ്കിലും ഇൻസ്റ്റളേഷൻ കൂടാതെ വേഗത്തിൽ ഫോർമാറ്റിംഗ് ആവശ്യമുണ്ടെങ്കിൽ, അല്ലെങ്കിൽ നിങ്ങൾ വിവിധ ഡാറ്റാബേസ് സിസ്റ്റങ്ങളിൽ പ്രവർത്തിക്കുന്നുവെങ്കിൽ, ബ്രൗസർ അടിസ്ഥാനമാക്കിയുള്ള ഉപകരണം കൂടുതൽ പ്രാക്ടിക്കൽ ആണ്.

എഡിറ്റർ വിപുലീകരണങ്ങൾ

VS Code അല്ലെങ്കിൽ Sublime Text-ൽ SQL എഴുതുന്നുവെങ്കിൽ, SQL Beautify അല്ലെങ്കിൽ SqlBeautifier പോലുള്ള വിപുലീകരണങ്ങൾ നിങ്ങളുടെ എഡിറ്ററിൽ ഫോർമാറ്റിംഗ് കൊണ്ടുവരുന്നു. നിങ്ങൾ സജീവമായി ക്വറികൾ എഴുതുകയാണെങ്കിൽ ഇത് നന്നായി പ്രവർത്തിക്കുന്നു.

പരിമിതി: വിപുലീകരണങ്ങൾക്ക് കോൺഫിഗറേഷൻ ആവശ്യമാണ്, അവ നിങ്ങളുടെ പ്രത്യേക എഡിറ്ററുമായി ബന്ധിക്കപ്പെട്ടിരിക്കുന്നു. SQL സഹപ്രവർത്തകരുമായി പങ്കിടുമ്പോൾ അല്ലെങ്കിൽ പ്രമാണീകരണത്തിൽ ക്വറികൾ പോസ്റ്റ് ചെയ്യുമ്പോൾ, ഒരു സ്റ്റാൻഡേർഡ് വെബ് ഫോർമാറ്റർ എല്ലാവർക്കും ഒരേ ഫോർമാറ്റിംഗ് കാണാൻ ഉറപ്പാക്കുന്നു.

കമാൻഡ്-ലൈൻ ഫോർമാറ്ററുകൾ

sqlformat (Python) അല്ലെങ്കിൽ sql-formatter-cli (Node.js) പോലുള്ള ഉപകരണങ്ങൾ CI/CD പൈപ്പ്ലൈനുകളിൽ സ്വയം ഫോർമാറ്റ് ചെയ്യാൻ സംയോജിക്കാൻ കഴിയും. ഇത് ഒരു ടീമിൽ സ്ഥിരത ഉറപ്പാക്കുന്നു.

ഓട്ടോമേറ്റഡ് വർക്ക്ഫ്ലോകൾക്ക് മികച്ചത്. നിങ്ങൾ ചിലത്ര ക്വറികൾ വൃത്തിയാക്കുകയാണോ അല്ലെങ്കിൽ SQL പഠിക്കുകയാണോ, കമാൻഡ്-ലൈൻ ഉപകരണങ്ങൾ അനാവശ്യമായ സങ്കീർണ്ണതകൾ കൂട്ടിച്ചേർക്കുന്നു.

SQL ഫോർമാറ്റിംഗ് സ്റ്റാൻഡേർഡ് പ്രാക്റ്റീസ് ആയി എങ്ങനെ വന്നു

SQL 1970-കളിൽ IBM-ൽ വികസിപ്പിച്ചെങ്കിലും, ഫോർമാറ്റിംഗ് കൺവെൻഷൻസ് വളരെ പിന്നീടാണ് വന്നത്. നിലവിലുണ്ടായിരുന്ന SQL പ്രവർത്തനക്ഷമമായിരുന്നെങ്കിലും സ്ഥിരതയില്ലാത്തതായിരുന്നു—ഓരോ ഡെവലപ്പർ വ്യത്യസ്തമായി ക്വറികൾ ഫോർമാറ്റ് ചെയ്തിരുന്നു.

1990-കളിൽ ഒരു തിരിച്ചുവരവ് സംഭവിച്ചു, ഡാറ്റാബേസുകൾ ഒറ്റ ഡെവലപ്പർ പദ്ധതികളിൽ നിന്ന് ടീം അടിസ്ഥാനമുള്ള വികസനത്തിലേക്ക് മാറി. സംഘടനകൾ സ്ഥിരതയുടെ ഉറപ്പിനായി ആന്തരിക SQL സ്റ്റൈൽ മാർഗ്ഗനിർദ്ദേശങ്ങൾ തുടങ്ങി. അഞ്ച് ഡെവലപ്പർമാർ ഒരേ ഡാറ്റാബേസിൽ പ്രവർത്തിക്കുമ്പോൾ, വായിക്കാവുന്ന SQL സഹകരണത്തിന് അത്യന്തം അനിവാര്യമായിരുന്നു.

2000-കളിൽ ഓ.ആർ.എം.കൾ (ഒബ്ജക്റ്റ് റിലേഷണൽ മാപ്പിംഗ്) വന്നു, അവ SQL സ്വയമേവ സൃഷ്ടിച്ചു. ഈ ഉപകരണങ്ങൾ പ്രവർത്തനക്ഷമമെങ്കിലും കുൽമുഖമായ SQL നിർമ്മിച്ചു—ഒരു വരിയിൽ എല്ലാം, യാതൊരു ഇൻഡന്റേഷനുമില്ലാതെ. ഇതു സ്വയം-ജനിതമായ SQL-ിനെ മനുഷ്യനാൽ വായിക്കാവുന്ന രൂപത്തിലാക്കാനുള്ള സ്വയം-ഫോർമാറ്റർകൾക്ക് ആവശ്യം സൃഷ്ടിച്ചു.

2010-കളിൽ വെബ് വികസനം വളർന്നതിനൊപ്പം ഓൺലൈൻ SQL ഫോർമാറ്റർമാർ പ്രത്യക്ഷപ്പെട്ടു. ഉപകരണങ്ങൾ ഇൻസ്റ്റാൾ ചെയ്യുകയോ IDE പ്ലഗിനുകൾ കോൺഫിഗർ ചെയ്യുകയോ ചെയ്യാതെ, ഡെവലപ്പർമാർക്ക് ബ്രൗസറിൽ SQL ഫോർമാറ്റ് ചെയ്യാൻ കഴിഞ്ഞു. ഇത് SQL പഠിക്കുന്ന തുടക്കക്കാർ മുതൽ അനുഭവസമ്പന്നരായ ഡെവലപ്പർമാർ വരെ യഥാവിധി ഫോർമാറ്റിംഗിലേക്ക് പ്രവേശനം സുഗമമാക്കി.

ഇന്ന്, SQL ഫോർമാറ്റിംഗ് മറ്റ് പ്രോഗ്രാമിംഗ് ഭാഷകളിലെ കോഡ് ഫോർമാറ്റിംഗ് പോലെ അടിസ്ഥാന പ്രാക്റ്റീസ് കണക്കാക്കപ്പെടുന്നു. സൈമൺ ഹോളിവെൽ നൽകിയ SQL സ്റ്റൈൽ മാർഗ്ഗനിർദ്ദേശം വ്യാപകമായി അംഗീകരിക്കപ്പെട്ട കൺവെൻഷൻസ് നൽകുന്നു, മാത്രമല്ല ഇത്തരം ഉപകരണങ്ങൾ ഈ മാനങ്ങൾ സ്വയമേവ നടപ്പിലാക്കുന്നു.

കോഡ് ഉദാഹരണങ്ങൾ

ഉദാഹരണം 1: അടിസ്ഥാന SELECT ക്വറി

ഫോർമാറ്റ് ചെയ്യാത്തത്:

1select id, first_name, last_name, email from customers where status = 'active' order by last_name, first_name;
2

ഫോർമാറ്റ് ചെയ്തത്:

1SELECT
2  id,
3  first_name,
4  last_name,
5  email
6FROM
7  customers
8WHERE
9  status = 'active'
10ORDER BY
11  last_name,
12  first_name;
13

ഉദാഹരണം 2: JOIN ക്വറി

ഫോർമാറ്റ് ചെയ്യാത്തത്:

1select c.id, c.name, o.order_date, o.total_amount from customers c left join orders o on c.id = o.customer_id where o.order_date >= '2023-01-01' and o.status != 'cancelled' order by o.order_date desc;
2

ഫോർമാറ്റ് ചെയ്തത്:

1SELECT
2  c.id,
3  c.name,
4  o.order_date,
5  o.total_amount
6FROM
7  customers c
8  LEFT JOIN orders o ON c.id = o.customer_id
9WHERE
10  o.order_date >= '2023-01-01'
11  AND o.status != 'cancelled'
12ORDER BY
13  o.order_date DESC;
14

ഉദാഹരണം 3: സബ്ക്വറിയുള്ള സങ്കീർണ്ണ ക്വറി

ഫോർമാറ്റ് ചെയ്യാത്തത്:

1select d.department_name, (select count(*) from employees e where e.department_id = d.id) as employee_count, (select avg(salary) from employees e where e.department_id = d.id) as avg_salary from departments d where d.active = true having employee_count > 0 order by avg_salary desc;
2

ഫോർമാറ്റ് ചെയ്തത്:

1SELECT
2  d.department_name,
3  (
4    SELECT
5      COUNT(*)
6    FROM
7      employees e
8    WHERE
9      e.department_id = d.id
10  ) AS employee_count,
11  (
12    SELECT
13      AVG(salary)
14    FROM
15      employees e
16    WHERE
17      e.department_id = d.id
18  ) AS avg_salary
19FROM
20  departments d
21WHERE
22  d.active = TRUE
23HAVING
24  employee_count > 0
25ORDER BY
26  avg_salary DESC;
27

പ്രോഗ്രാമ്മാറ്റിക് SQL ഫോർമാറ്റിംഗ്

വിവിധ പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ SQL ഫോർമാറ്റിംഗ് നടപ്പിലാക്കുന്നതിനുള്ള ഉദാഹരണങ്ങൾ ഇവിടെയുണ്ട്:

1// JavaScript SQL ഫോർമാറ്റിംഗ് ഉദാഹരണം sql-formatter പുസ്തകാലയം ഉപയോഗിച്ച്
2const sqlFormatter = require('sql-formatter');
3
4function formatSQL(sql) {
5  return sqlFormatter.format(sql, {
6    language: 'sql',
7    uppercase: true,
8    linesBetweenQueries: 2,
9    indentStyle: 'standard'
10  });
11}
12
13const rawSQL = "select id, name from users where status='active'";
14const formattedSQL = formatSQL(rawSQL);
15console.log(formattedSQL);
16

1# Python SQL ഫോർമാറ്റിംഗ് ഉദാഹരണം sqlparse ഉപയോഗിച്ച്
2import sqlparse
3
4def format_sql(sql):
5    return sqlparse.format(
6        sql,
7        reindent=True,
8        keyword_case='upper',
9        identifier_case='lower',
10        indent_width=2
11    )
12
13raw_sql = "select id, name from users where status='active'"
14formatted_sql = format_sql(raw_sql)
15print(formatted_sql)
16

1// Java SQL ഫോർമാറ്റിംഗ് ഉദാഹരണം JSqlParser ഉപയോഗിച്ച്
2import net.sf.jsqlparser.parser.CCJSqlParserUtil;
3import net.sf.jsqlparser.statement.Statement;
4
5public class SQLFormatter {
6    public static String formatSQL(String sql) throws Exception {
7        Statement statement = CCJSqlParserUtil.parse(sql);
8        return statement.toString()
9            .replaceAll("(?i)SELECT", "\nSELECT")
10            .replaceAll("(?i)FROM", "\nFROM")
11            .replaceAll("(?i)WHERE", "\nWHERE")
12            .replaceAll("(?i)ORDER BY", "\nORDER BY");
13    }
14    
15    public static void main(String[] args) throws Exception {
16        String rawSQL = "select id, name from users where status='active'";
17        String formattedSQL = formatSQL(rawSQL);
18        System.out.println(formattedSQL);
19    }
20}
21

1<?php
2// PHP SQL ഫോർമാറ്റിംഗ് ഉദാഹരണം
3function formatSQL($sql) {
4    // കീവേഡുകളെ വലിയക്ഷരത്തിൽ മാറ്റുക
5    $keywords = ['SELECT', 'FROM', 'WHERE', 'JOIN', 'LEFT JOIN', 'RIGHT JOIN', 
6                 'INNER JOIN', 'GROUP BY', 'ORDER BY', 'HAVING', 'LIMIT'];
7    
8    $formattedSQL = $sql;
9    foreach ($keywords as $keyword) {
10        $formattedSQL = preg_replace('/\b' . preg_quote($keyword, '/') . '\b/i', "\n$keyword", $formattedSQL);
11    }
12    
13    // ഇൻഡന്റേഷൻ ചേർക്കുക
14    $lines = explode("\n", $formattedSQL);
15    $result = '';
16    $indentLevel = 0;
17    
18    foreach ($lines as $line) {
19        $trimmedLine = trim($line);
20        if (!empty($trimmedLine)) {
21            $result .= str_repeat("  ", $indentLevel) . $trimmedLine . "\n";
22        }
23    }
24    
25    return $result;
26}
27
28$rawSQL = "select id, name from users where status='active'";
29$formattedSQL = formatSQL($rawSQL);
30echo $formattedSQL;
31?>
32

വ്യാപകമായി ചോദിക്കപ്പെടുന്ന ചോദ്യങ്ങൾ

ഈ SQL ഫോർമാറ്റർ PostgreSQL, MySQL, SQL Server എന്നിവയുമായി പ്രവർത്തിക്കുമോ?

അതെ, ഇത് പ്രധാന ഡേറ്റാബേസുകളിൽ സാധാരണ SQL സിന്റാക്സ് കൈകാര്യം ചെയ്യുന്നു—PostgreSQL, MySQL, SQL Server (T-SQL), Oracle, SQLite, MariaDB. ഫോർമാറ്റർ ഏവിടത്തും പ്രവർത്തിക്കുന്ന കോർ SQL-ൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നു: SELECT, JOIN, WHERE, GROUP BY മുതലായവ.

ഡേറ്റാബേസ്-പ്രത്യേക സവിശേഷതകൾ പൂർണ്ണമായി ഫോർമാറ്റ് ചെയ്യപ്പെടാതിരിക്കാം. ഉദാഹരണത്തിന്, PostgreSQL-ന്റെ അരേ സിന്റാക്സ് അല്ലെങ്കിൽ SQL Server-ന്റെ പ്രോപ്രൈറ്ററി ഫംഗ്ഷനുകൾക്ക് പ്രത്യേക ഫോർമാറ്റിംഗ് ലഭിക്കില്ല, പക്ഷേ ഫോർമാറ്റർ തകരുകയുമില്ല. ക്വറി മുമ്പിലുമുള്ളതിനേക്കാൾ വായിക്കാൻ എളുപ്പമാകും.

എന്റെ SQL കോഡ് സെർവറിലേക്ക് അയയ്ക്കപ്പെടുന്നുണ്ടോ?

ഇല്ല. എല്ലാം നിങ്ങളുടെ ബ്രൗസറിൽ നടക്കുന്നു. SQL കോഡ് പേസ്റ്റ് ചെയ്യുക, അത് നെറ്റ്വർക്ക് അഭ്യർഥനകൾ ഇല്ലാതെ പ്രാദേശികമായി ഫോർമാറ്റ് ചെയ്യപ്പെടുന്നു. നിങ്ങളുടെ ക്വറികൾ നിങ്ങളുടെ മെഷീനിൽ നിന്ന് പുറത്തുപോകുന്നില്ല.

ഇത് ഉൽപ്പാദന ഡേറ്റാബേസ് സ്കീമകളിലോ വ്യാവസായിക ബിസിനസ് ലോജിക്കിലോ പ്രവർത്തിക്കുമ്പോൾ പ്രധാനമാണ്. സംവേദനീയ വിവരങ്ങൾ മറ്റാരുടെയെങ്കിലും സെർവറിൽ രേഖപ്പെടുത്തുകയോ സൂക്ഷിക്കുകയോ ചെയ്യുന്ന അപകടസാധ്യത ഇല്ല.

(ബാക്കി ഭാഗം തുടരുന്നു...)

അനുസന്ധാനങ്ങളും കൂടുതൽ വായനയ്ക്കുള്ള വിവരങ്ങളും

സൈമൺ ഹോളിവെൽ നൽകിയ SQL സ്റ്റൈൽ മാർഗ്ഗനിർദ്ദേശം - വികസന സംഘങ്ങൾ ഉപയോഗിക്കുന്ന SQL ഫോർമാറ്റിംഗ് കൺവെൻഷൻസിനുള്ള വാസ്തവിക സ്റ്റാൻഡേർഡ്
ISO/IEC 9075 SQL സ്റ്റാൻഡേർഡ് - ഔദ്യോഗിക അന്തർദ്ദേശീയ SQL സ്റ്റാൻഡേർഡ് നിർവ്വചനം
PostgreSQL SQL സിന്റാക്സ് പ്രമാണീകരണം - PostgreSQL യുടെ വിശദമായ SQL സിന്റാക്സ് സന്ദർഭം
മൈക്രോസോഫ്റ്റ് T-SQL റഫറൻസ് - SQL സർവ്വറിന്റെ T-SQL ഭാഷയുടെ ഔദ്യോഗിക പ്രമാണീകരണം
MySQL റഫറൻസ് മാനുവൽ - MySQL യുടെ പൂർണ്ണ SQL സ്റ്റേറ്റ്മെന്റ് സന്ദർഭം

SQL ഫോർമാറ്റിംഗ് ആരംഭിക്കുക

വായിക്കാവുന്ന SQL പിഴവുകൾ കണ്ടെത്തുന്നതിനെ വേഗത്തിലാക്കുകയും, കോഡ് അവലോകനങ്ങൾ എളുപ്പമാക്കുകയും, സഹകരണം കൂടുതൽ സുഗമമാക്കുകയും ചെയ്യുന്നു. വ്യവസായ നിലവാര നിഘണ്ടുവിന് അനുസൃതമായി നിങ്ങളുടെ അന്വേഷണം ഫോർമാറ്റ് ചെയ്യുന്നതിന് മുകളിൽ നിങ്ങളുടെ അന്വേഷണം പേസ്റ്റ് ചെയ്യുക - യാതൊരു ഇൻസ്റ്റളേഷനും, കോൺഫിഗറേഷനും, നിങ്ങളുടെ ബ്രൗസറിൽ നിന്ന് യാതൊരു ഡാറ്റയും പുറത്തുകടക്കുന്നില്ല.

SQL ഫോർമാറ്റർ & വാലിഡേറ്റർ - ഓൺലൈൻ സൗജന്യ SQL ക്വറികൾ ഫോർമാറ്റ് ചെയ്യുക

വിവരണം

SQL ഫോർമാറ്റിംഗ് എന്തുകൊണ്ട് പ്രധാനമാണ്

SQL ഫോർമാറ്റർ ഉപയോഗിക്കുന്ന വിധം

SQL ഫോർമാറ്റർ എന്ത് ചെയ്യുന്നു

കീവേഡ് മുതലക്ഷരം വലുതാക്കൽ

സ്മാർട്ട് ഇൻഡന്റേഷൻ

താർക്കിക വരി വിഭജനം

SQL വാലിഡേഷൻ: എന്താണ് പരിശോധിക്കുന്നത്

സ്ട്രക്ചറൽ പിഴവുകൾ

ലോജിക്കൽ പിഴവുകൾ

ഇത് കണ്ടെത്തില്ല

ഫോർമാറ്റിംഗ് നിയമങ്ങൾ ഈ ഉപകരണം പ്രയോഗിക്കുന്നു

കീവേഡുകൾ മുതലക്ഷരം വലുതാക്കുന്നു

ഓരോ തലത്തിനും രണ്ട് സ്പേസ് ഇൻഡന്റേഷൻ

മുൻപും ശേഷവും: വ്യത്യാസം കാണുക

സാധുതാ നിയമങ്ങൾ: എന്തൊക്കെ ഫ്ലാഗ് ചെയ്യപ്പെടുന്നു

സ്ട്രക്ചറൽ പരിശോധനകൾ

താർക്കിക സ്ഥിരതാ പരിശോധനകൾ

പൊതുവായ പിഴവുകൾ കണ്ടെത്തിയ ഉദാഹരണം

SQL ഫോർമാറ്റർ ഉപയോഗിക്കേണ്ട സമയം

കോഡ് പരിശോധനയിൽ

ഉൽപ്പാദന പ്രശ്നങ്ങൾ ഡീബഗ് ചെയ്യുമ്പോൾ

ജനറേറ്റ് ചെയ്ത SQL വർക്ക് ചെയ്യുമ്പോൾ

SQL പഠിക്കുകയും പഠിപ്പിക്കുകയും ചെയ്യുമ്പോൾ

ഡാറ്റാബേസ് സിസ്റ്റങ്ങൾ മൈഗ്രേറ്റ് ചെയ്യുമ്പോൾ

ഈ SQL ഫോർമാറ്റർക്കുള്ള ബദൽ സംവിധാനങ്ങൾ

ഡാറ്റാബേസ് നിർദ്ദിഷ്ട IDE കൾ

എഡിറ്റർ വിപുലീകരണങ്ങൾ

കമാൻഡ്-ലൈൻ ഫോർമാറ്ററുകൾ

SQL ഫോർമാറ്റിംഗ് സ്റ്റാൻഡേർഡ് പ്രാക്റ്റീസ് ആയി എങ്ങനെ വന്നു

കോഡ് ഉദാഹരണങ്ങൾ

ഉദാഹരണം 1: അടിസ്ഥാന SELECT ക്വറി

ഉദാഹരണം 2: JOIN ക്വറി

ഉദാഹരണം 3: സബ്ക്വറിയുള്ള സങ്കീർണ്ണ ക്വറി

പ്രോഗ്രാമ്മാറ്റിക് SQL ഫോർമാറ്റിംഗ്

വ്യാപകമായി ചോദിക്കപ്പെടുന്ന ചോദ്യങ്ങൾ

ഈ SQL ഫോർമാറ്റർ PostgreSQL, MySQL, SQL Server എന്നിവയുമായി പ്രവർത്തിക്കുമോ?

എന്റെ SQL കോഡ് സെർവറിലേക്ക് അയയ്ക്കപ്പെടുന്നുണ്ടോ?

അനുസന്ധാനങ്ങളും കൂടുതൽ വായനയ്ക്കുള്ള വിവരങ്ങളും

SQL ഫോർമാറ്റിംഗ് ആരംഭിക്കുക