SQL സെർവറിൽ ഒരു നിരയും അപ്‌ഡേറ്റ് വരികളും എങ്ങനെ ഫലപ്രദമായി ചേർക്കാം

SQL സെർവറിലെ മാസ്റ്ററിംഗ് ടേബിൾ പരിഷ്‌ക്കരണങ്ങൾ: ഒരു ഘട്ടം ഘട്ടമായുള്ള ഗൈഡ്

ചിലപ്പോൾ, വലിയ ഡാറ്റാസെറ്റുകളിൽ പ്രവർത്തിക്കുന്നത് ഒരേസമയം നൂറ് ടാസ്ക്കുകൾ കൈകാര്യം ചെയ്യാൻ ശ്രമിക്കുന്നതായി തോന്നാം. അടുത്തിടെ, ഒരു ദശലക്ഷത്തിലധികം വരികൾ അടങ്ങിയ ഒരു പട്ടികയിലേക്ക് ഒരു കോളം ചേർക്കേണ്ട ഒരു സാഹചര്യത്തിൽ ഞാൻ എന്നെത്തന്നെ കണ്ടെത്തി. ഉപരിതലത്തിൽ ഇതൊരു ലളിതമായ ജോലിയായി തോന്നുമെങ്കിലും, നിരവധി SQL സെർവർ ഉപയോക്താക്കൾ അഭിമുഖീകരിക്കുന്ന ഒരു റോഡ്ബ്ലോക്കിലേക്ക് ഞാൻ പെട്ടെന്ന് ഓടിയെത്തി: ഭയാനകമായ "അസാധുവായ കോളത്തിൻ്റെ പേര്" പിശക്. 🧐

എൻ്റെ ആൾട്ടർ ടേബിളും അപ്‌ഡേറ്റ് കമാൻഡും ഒരുമിച്ച് എക്‌സിക്യൂട്ട് ചെയ്യാനുള്ള നിരവധി ശ്രമങ്ങൾ നടത്തിയ ശേഷം, പ്രശ്‌നം യുക്തിയിലല്ല, എൻ്റെ അന്വേഷണങ്ങളുടെ ക്രമത്തിലാണെന്ന് ഞാൻ മനസ്സിലാക്കി. SQL സെർവറിന് നിങ്ങൾ ആദ്യം കോളം ചേർക്കുകയും ഏതെങ്കിലും ഡാറ്റ ഉപയോഗിച്ച് അത് അപ്‌ഡേറ്റ് ചെയ്യുന്നതിന് മുമ്പ് ആ മാറ്റം വരുത്തുകയും വേണം. അങ്ങനെ ചെയ്യുന്നതിൽ പരാജയപ്പെടുന്നത് ഒരു പിശകിന് കാരണമാകുന്നു, കാരണം അപ്‌ഡേറ്റ് എക്‌സിക്യൂട്ട് ചെയ്യുന്ന സമയത്ത് പുതിയതായി ചേർത്ത കോളം സിസ്റ്റം തിരിച്ചറിയുന്നില്ല.

ഉദാഹരണത്തിന്, ഒരു വലിയ ഉപഭോക്തൃ ഡാറ്റാബേസിനായി ഒരു നിർദ്ദിഷ്ട തീയതി പരിധി അടിസ്ഥാനമാക്കി "IS_CURRENT" ഫ്ലാഗ് അപ്ഡേറ്റ് ചെയ്യാൻ നിങ്ങളെ ചുമതലപ്പെടുത്തിയതായി സങ്കൽപ്പിക്കുക. നിങ്ങൾ കോളം ചേർത്ത് ഒറ്റ സ്‌ക്രിപ്റ്റിൽ വരികൾ അപ്‌ഡേറ്റ് ചെയ്യാൻ ശ്രമിക്കുകയാണെങ്കിൽ, SQL സെർവർ "അസാധുവായ കോളത്തിൻ്റെ പേര്" പിശക് വരുത്തിയേക്കാം. അപ്‌ഡേറ്റ് ചോദ്യം ഉപയോഗിക്കുന്നതിന് മുമ്പ് കോളം പൂർണ്ണമായും പ്രതിജ്ഞാബദ്ധമല്ല എന്നതാണ് ഇതിന് കാരണം. 🚀

ഈ ലേഖനത്തിൽ, കോളം ചേർക്കുന്നതിനും വരികൾ അപ്‌ഡേറ്റ് ചെയ്യുന്നതിനുമുള്ള ശരിയായ ക്രമത്തിലൂടെ ഞങ്ങൾ സഞ്ചരിക്കും, വലിയ ഡാറ്റാസെറ്റുകളിൽ പോലും സുഗമമായ നിർവ്വഹണം ഉറപ്പാക്കുന്നു. ദശലക്ഷക്കണക്കിന് വരികൾ കാര്യക്ഷമമായി കൈകാര്യം ചെയ്യുന്നതിനായി SQL സ്ക്രിപ്റ്റുകൾ ഒപ്റ്റിമൈസ് ചെയ്യുന്നതിനുള്ള നുറുങ്ങുകളിലേക്കും ഞങ്ങൾ മുഴുകും, നിങ്ങളുടെ ഡാറ്റാ പ്രവർത്തനങ്ങൾ തടസ്സമില്ലാതെ പ്രവർത്തിക്കുന്നുവെന്ന് ഉറപ്പാക്കും. ഞങ്ങൾ ഘട്ടങ്ങൾ പര്യവേക്ഷണം ചെയ്യുകയും വഴിയിലെ പൊതുവായ പ്രശ്‌നങ്ങൾ പരിഹരിക്കുകയും ചെയ്യുമ്പോൾ തുടരുക!

പട്ടികകൾ മാറ്റുന്നതിനും വരികൾ അപ്ഡേറ്റ് ചെയ്യുന്നതിനുമുള്ള SQL സെർവർ കമാൻഡുകൾ മനസ്സിലാക്കുന്നു

SQL സെർവറുമായി പ്രവർത്തിക്കുമ്പോൾ, പ്രത്യേകിച്ച് വലിയ ഡാറ്റാസെറ്റുകൾ അടങ്ങിയ പട്ടികകളിൽ, ഒരു പട്ടിക മാറ്റുന്നതിനും അതിൻ്റെ വരികൾ അപ്‌ഡേറ്റ് ചെയ്യുന്നതിനുമുള്ള ഒരു ചിട്ടയായ സമീപനം പിന്തുടരുന്നത് നിർണായകമാണ്. ഒരു പൊതു സാഹചര്യത്തിന്, ഒരു പട്ടികയിലേക്ക് ഒരു പുതിയ കോളം ചേർക്കേണ്ടതുണ്ട്, തുടർന്ന് തീയതികളെ അടിസ്ഥാനമാക്കി ഒരു ഫ്ലാഗ് സജ്ജീകരിക്കുന്നത് പോലെയുള്ള നിർദ്ദിഷ്ട വ്യവസ്ഥകളെ അടിസ്ഥാനമാക്കി വരികൾ അപ്‌ഡേറ്റ് ചെയ്യേണ്ടത് ആവശ്യമാണ്. ഞാൻ നൽകിയ സ്ക്രിപ്റ്റ് ഇതിനുള്ള ഒരു ലളിതമായ സമീപനം പ്രകടമാക്കുന്നു, എന്നാൽ ഈ ടാസ്ക്കുകൾ കാര്യക്ഷമമായി നേടുന്നതിന് അത്യന്താപേക്ഷിതമായ പ്രധാന SQL സെർവർ കമാൻഡുകൾ ഇത് ഹൈലൈറ്റ് ചെയ്യുന്നു. ദി ആൾട്ടർ ടേബിൾ പട്ടികയിൽ ഒരു പുതിയ കോളം ചേർക്കാൻ കമാൻഡ് ഉപയോഗിക്കുന്നു. ഉദാഹരണത്തിന്, ഞങ്ങൾ `ALTER TABLE dbo.sample ADD IS_CURRENT BIT;` റൺ ചെയ്യുമ്പോൾ, `BIT` (ഒരു ബൂളിയൻ തരം, ഒന്നുകിൽ 0 അല്ലെങ്കിൽ 1) `IS_CURRENT` എന്ന പേരിൽ ഒരു പുതിയ കോളം അവതരിപ്പിക്കുന്നതിനായി ഞങ്ങൾ പട്ടികയുടെ ഘടന പരിഷ്‌ക്കരിക്കുന്നു.

കോളം ചേർത്ത ശേഷം, അടുത്ത ഘട്ടം ചില വ്യവസ്ഥകളെ അടിസ്ഥാനമാക്കി പട്ടികയിലെ വരികൾ അപ്ഡേറ്റ് ചെയ്യുക എന്നതാണ്. ഉപയോഗിച്ച് ഇത് നേടിയെടുക്കുന്നു അപ്ഡേറ്റ് ചെയ്യുക കമാൻഡ്. ഉദാഹരണത്തിന്, ചോദ്യം `UPDATE dbo.sample SET IS_CURRENT = 0 WHERE LOAD_DATE

ചില സന്ദർഭങ്ങളിൽ, പ്രത്യേകിച്ച് ദശലക്ഷക്കണക്കിന് വരികൾ അടങ്ങിയ വലിയ ടേബിളുകൾ കൈകാര്യം ചെയ്യുമ്പോൾ, SQL കമാൻഡുകൾ കാര്യക്ഷമമായി നടപ്പിലാക്കുന്നുവെന്ന് ഉറപ്പാക്കേണ്ടത് പ്രധാനമാണ്. ഇവിടെയാണ് പ്രവർത്തനങ്ങൾ പോലെയുള്ളത് DATEADD ഒപ്പം DATEDIFF കളിക്കുക. തീയതികൾ കൃത്യതയോടെ കൈകാര്യം ചെയ്യാനും താരതമ്യം ചെയ്യാനും ഈ പ്രവർത്തനങ്ങൾ നിങ്ങളെ അനുവദിക്കുന്നു. രണ്ടാമത്തെ അപ്‌ഡേറ്റ് ചോദ്യത്തിൽ, `DATEADD(മാസം, DATEDIFF(മാസം, 0, DATEADD(DAY, -60, GETDATE())), 0)` നിലവിലെ തീയതിയിൽ നിന്ന് (`GETDATE()`) 60 ദിവസം കുറയ്ക്കുകയും പുനഃസജ്ജമാക്കുകയും ചെയ്യുന്നു മാസത്തിൻ്റെ ആരംഭം വരെയുള്ള സമയം. ഈ ഫംഗ്‌ഷനുകൾ ഉപയോഗിക്കുന്നതിലൂടെ, സമയം പുരോഗമിക്കുമ്പോൾ ക്രമീകരിക്കുന്ന കൂടുതൽ ഡൈനാമിക് തീയതി ശ്രേണികൾ നമുക്ക് നിർവചിക്കാൻ കഴിയും, ഡാറ്റ പ്രായമാകുമ്പോഴും നിലവിലുള്ളതായി തുടരുന്നുവെന്ന് ഉറപ്പാക്കുന്നു.

എന്നിരുന്നാലും, `ALTER TABLE`, `UPDATE` എന്നീ രണ്ട് പ്രസ്താവനകളും ഒരൊറ്റ സ്ക്രിപ്റ്റിലേക്ക് സംയോജിപ്പിക്കുമ്പോൾ, SQL സെർവറിന് ചിലപ്പോൾ "അസാധുവായ നിരയുടെ പേര്" പിശക് ഇടാം. ഇതേ ബാച്ചിലെ തുടർന്നുള്ള അന്വേഷണങ്ങൾ നിർവ്വഹിക്കുമ്പോൾ `ALTER TABLE` ചേർത്ത കോളം SQL സെർവർ പൂർണ്ണമായി പ്രതിജ്ഞാബദ്ധമായിരിക്കുകയോ തിരിച്ചറിയുകയോ ചെയ്തേക്കില്ല എന്നതിനാലാണ് ഇത് സംഭവിക്കുന്നത്. ഈ പ്രശ്‌നത്തിനുള്ള പരിഹാരം, അപ്‌ഡേറ്റുകൾ നടത്തുന്നതിന് മുമ്പായി പട്ടികയിൽ മാറ്റം വരുത്തുന്നത് പൂർണ്ണമായും പ്രതിജ്ഞാബദ്ധമാണെന്ന് ഉറപ്പാക്കിക്കൊണ്ട് `ALTER TABLE` പ്രസ്താവനയും `UPDATE` കമാൻഡുകളും വേർതിരിക്കുക എന്നതാണ്. അങ്ങനെ ചെയ്യുന്നതിലൂടെ, SQL സെർവറിന് പുതിയ കോളം അതിൻ്റെ സ്കീമയിൽ ശരിയായി രജിസ്റ്റർ ചെയ്യപ്പെടും, ഇത് പട്ടികയിലേക്ക് സുഗമമായ അപ്‌ഡേറ്റുകൾ അനുവദിക്കുന്നു. വലിയ ഡാറ്റാസെറ്റുകൾ കൈകാര്യം ചെയ്യുമ്പോൾ, ഈ പ്രവർത്തനങ്ങൾ ബാച്ചുകളായി നിർവ്വഹിക്കുന്നതോ ഇടപാടുകൾ ഉപയോഗിച്ച് പ്രക്രിയ കഴിയുന്നത്ര കാര്യക്ഷമമാണെന്ന് ഉറപ്പാക്കാൻ, സാധ്യതയുള്ള സമയപരിധികളോ ലോക്കുകളോ ഒഴിവാക്കുന്നത് പരിഗണിക്കുക. 🚀

ALTER TABLE dbo.sample ADD IS_CURRENT BIT;
GO
UPDATE dbo.sample
SET IS_CURRENT = 0
WHERE LOAD_DATE < '2025-01-01';
GO
UPDATE dbo.sample
SET IS_CURRENT = 0
WHERE LOAD_DATE >= CAST(DATEADD(month, DATEDIFF(month, 0, DATEADD(DAY, -60, GETDATE())), 0) AS DATE);
GO

BEGIN TRANSACTION;
ALTER TABLE dbo.sample ADD IS_CURRENT BIT;
UPDATE dbo.sample
SET IS_CURRENT = 0
WHERE LOAD_DATE < '2025-01-01';
UPDATE dbo.sample
SET IS_CURRENT = 0
WHERE LOAD_DATE >= CAST(DATEADD(month, DATEDIFF(month, 0, DATEADD(DAY, -60, GETDATE())), 0) AS DATE);
COMMIT TRANSACTION;

DECLARE @BatchSize INT = 10000;
DECLARE @RowCount INT;
SELECT @RowCount = COUNT(*) FROM dbo.sample WHERE IS_CURRENT IS ;
WHILE @RowCount > 0
BEGIN
    UPDATE TOP (@BatchSize) dbo.sample
    SET IS_CURRENT = 0
    WHERE LOAD_DATE < '2025-01-01' AND IS_CURRENT IS ;
    SET @RowCount = @RowCount - @BatchSize;
END

CREATE VIEW dbo.Sample_View AS
SELECT LOAD_DATE, IS_CURRENT
FROM dbo.sample
WHERE LOAD_DATE < '2025-01-01';
GO
CREATE UNIQUE CLUSTERED INDEX idx_sample_view ON dbo.Sample_View (LOAD_DATE);
GO
UPDATE dbo.sample
SET IS_CURRENT = 0
FROM dbo.Sample_View v
WHERE dbo.sample.LOAD_DATE = v.LOAD_DATE;
GO

EXEC msdb.dbo.sp_add_job @job_name = 'Update IS_CURRENT Job';
EXEC msdb.dbo.sp_add_jobstep @job_name = 'Update IS_CURRENT Job',
@step_name = 'Update IS_CURRENT Step',
@subsystem = 'TSQL',
@command = 'UPDATE dbo.sample SET IS_CURRENT = 0 WHERE LOAD_DATE < ''2025-01-01'';',
@retry_attempts = 5, @retry_interval = 5;
EXEC msdb.dbo.sp_add_schedule @schedule_name = 'Daily Schedule',
@enabled = 1, @freq_type = 4, @freq_interval = 1, @active_start_time = 010000;
EXEC msdb.dbo.sp_attach_schedule @job_name = 'Update IS_CURRENT Job', @schedule_name = 'Daily Schedule';
EXEC msdb.dbo.sp_start_job @job_name = 'Update IS_CURRENT Job';

സ്ക്രിപ്റ്റുകളിൽ ഉപയോഗിച്ചിരിക്കുന്ന പ്രത്യേക SQL കമാൻഡുകളുടെ വിശദീകരണം

വലിയ ടേബിളുകൾക്കായി SQL സെർവർ സ്ക്രിപ്റ്റുകൾ ഒപ്റ്റിമൈസ് ചെയ്യുന്നു

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

പ്രകടന പ്രശ്‌നങ്ങൾ ലഘൂകരിക്കുന്നതിന്, ടാസ്‌ക്കുകളെ ചെറിയ ഘട്ടങ്ങളായി വിഭജിക്കുക എന്നതാണ് ഏറ്റവും മികച്ച സമീപനങ്ങളിലൊന്ന്. ഉദാഹരണത്തിന്, ഒരു കോളം ചേർക്കുകയും എല്ലാ വരികളും ഒരൊറ്റ സ്ക്രിപ്റ്റിൽ അപ്ഡേറ്റ് ചെയ്യുകയും ചെയ്യുന്നതിനുപകരം, റൺ ചെയ്യുന്നത് പരിഗണിക്കുക ആൾട്ടർ ടേബിൾ കമാൻഡ് വെവ്വേറെ, തുടർന്ന് ബാച്ച് ചെയ്യുക UPDATE പ്രവർത്തനങ്ങൾ. ചെറിയ ഭാഗങ്ങളായി റെക്കോർഡുകൾ അപ്ഡേറ്റ് ചെയ്യുന്നതിലൂടെ, സ്ക്രിപ്റ്റ് സെർവറിനെ മറികടക്കില്ല. നിങ്ങൾക്ക് പ്രയോജനപ്പെടുത്താം UPDATE TOP ഓരോ ഇടപാടിലും ബാധിച്ച വരികളുടെ എണ്ണം പരിമിതപ്പെടുത്താനുള്ള കമാൻഡ്. കൂടാതെ, നിങ്ങളുടേതിൽ ഉപയോഗിക്കുന്ന നിരകളിൽ സൂചികകൾ സൃഷ്ടിക്കുന്നതും നല്ലതാണ് WHERE ഉപവാക്യങ്ങൾ (ഉദാ LOAD_DATE) തിരയൽ പ്രക്രിയ വേഗത്തിലാക്കാൻ. വലിയ ഡാറ്റാസെറ്റുകൾക്ക്, തീയതി ശ്രേണികളെ അടിസ്ഥാനമാക്കി വരികൾ ഫിൽട്ടർ ചെയ്യാൻ എടുക്കുന്ന സമയം സൂചികകൾ കുറയ്ക്കുന്നു.

പ്രവർത്തനങ്ങൾ ആറ്റോമികമായി നിർവ്വഹിക്കുന്നുവെന്ന് ഉറപ്പാക്കാൻ ഇടപാടുകളുടെയും പിശക് കൈകാര്യം ചെയ്യുന്നതിൻ്റെയും ഉപയോഗമാണ് മറ്റൊരു പ്രധാന പരിഗണന. നിങ്ങളുടെ പൊതിയുന്നതിലൂടെ UPDATE ഉള്ളിലുള്ള പ്രസ്താവനകൾ a BEGIN TRANSACTION ഒപ്പം COMMIT, മാറ്റങ്ങൾ സുരക്ഷിതവും സ്ഥിരവുമായ രീതിയിലാണെന്ന് നിങ്ങൾ ഉറപ്പാക്കുന്നു. പ്രക്രിയയുടെ ഏതെങ്കിലും ഭാഗം പരാജയപ്പെടുകയാണെങ്കിൽ, നിങ്ങൾക്ക് ഉപയോഗിക്കാം ROLLBACK ഭാഗികമായ അപ്ഡേറ്റുകൾ തടയുന്ന, മാറ്റങ്ങൾ പഴയപടിയാക്കാൻ. കൂടാതെ, തിരക്കില്ലാത്ത സമയങ്ങളിൽ സ്ക്രിപ്റ്റുകൾ പ്രവർത്തിപ്പിക്കുകയോ ഈ പ്രവർത്തനങ്ങൾ ഷെഡ്യൂൾ ചെയ്യുന്നതിന് SQL സെർവർ ഏജൻ്റ് ഉപയോഗിക്കുകയോ ചെയ്യുന്നത് സിസ്റ്റം പ്രകടനത്തിൽ കുറഞ്ഞ സ്വാധീനം ഉറപ്പാക്കുന്നു. ഈ ഒപ്റ്റിമൈസേഷനുകൾ ഉപയോഗിച്ച്, സിസ്റ്റം സമഗ്രത നിലനിർത്തിക്കൊണ്ട് നിങ്ങൾക്ക് വലിയ പട്ടികകളിൽ സങ്കീർണ്ണമായ പരിഷ്ക്കരണങ്ങൾ സുരക്ഷിതമായി നടപ്പിലാക്കാൻ കഴിയും. 🖥️