SQL સર્વરમાં અસરકારક રીતે કૉલમ કેવી રીતે ઉમેરવી અને પંક્તિઓ અપડેટ કરવી

એસક્યુએલ સર્વરમાં માસ્ટરિંગ કોષ્ટક ફેરફારો: એક પગલું દ્વારા પગલું માર્ગદર્શિકા

કેટલીકવાર, મોટા ડેટાસેટ્સ સાથે કામ કરવું એકસાથે સો કાર્યોને જગલ કરવાનો પ્રયાસ કરવા જેવું લાગે છે. તાજેતરમાં, હું મારી જાતને એવી પરિસ્થિતિમાં જોઉં છું જ્યાં મને એક મિલિયનથી વધુ પંક્તિઓ ધરાવતા કોષ્ટકમાં કૉલમ ઉમેરવાની જરૂર છે. જ્યારે આ સપાટી પર એક સરળ કાર્ય જેવું લાગતું હતું, ત્યારે હું ઝડપથી એક રોડ બ્લોકમાં દોડી ગયો જેનો ઘણા SQL સર્વર વપરાશકર્તાઓ સામનો કરે છે: ભયજનક "અમાન્ય કૉલમ નામ" ભૂલ. 🧐

મારા ALTER TABLE અને UPDATE કમાન્ડને એકસાથે ચલાવવાના ઘણા પ્રયત્નો કર્યા પછી, મને સમજાયું કે સમસ્યા તર્ક સાથે નહીં પણ મારા પ્રશ્નોના ક્રમ સાથે હતી. SQL સર્વરને જરૂરી છે કે તમે પહેલા કૉલમ ઉમેરો અને કોઈપણ ડેટા સાથે તેને અપડેટ કરતા પહેલા તે ફેરફાર કરો. આમ કરવામાં નિષ્ફળતા ભૂલમાં પરિણમે છે કારણ કે અપડેટ એક્ઝિક્યુટ થાય તે સમયે સિસ્ટમ નવી ઉમેરવામાં આવેલી કૉલમને ઓળખતી નથી.

ઉદાહરણ તરીકે, કલ્પના કરો કે તમને મોટા ગ્રાહક ડેટાબેઝ માટે ચોક્કસ તારીખ થ્રેશોલ્ડના આધારે "IS_CURRENT" ફ્લેગ અપડેટ કરવાનું કામ સોંપવામાં આવ્યું છે. જો તમે કૉલમ ઉમેરો અને એક જ સ્ક્રિપ્ટમાં પંક્તિઓ અપડેટ કરવાનો પ્રયાસ કરો, તો SQL સર્વર "અમાન્ય કૉલમ નામ" ભૂલ ફેંકી શકે છે. આ એટલા માટે છે કારણ કે અપડેટ ક્વેરી તેનો ઉપયોગ કરવાનો પ્રયાસ કરે તે પહેલાં કૉલમ સંપૂર્ણપણે પ્રતિબદ્ધ નથી. 🚀

આ લેખમાં, અમે કૉલમ ઉમેરવા અને પંક્તિઓ અપડેટ કરવા માટે યોગ્ય ક્રમમાં જઈશું, મોટા ડેટાસેટ્સ સાથે પણ સરળ અમલીકરણની ખાતરી આપીશું. અમે લાખો પંક્તિઓને અસરકારક રીતે હેન્ડલ કરવા માટે SQL સ્ક્રિપ્ટને ઑપ્ટિમાઇઝ કરવા માટેની ટિપ્સમાં પણ ડાઇવ કરીશું, ખાતરી કરીને કે તમારા ડેટા ઑપરેશન્સ કોઈ અડચણ વિના ચાલે છે. અમે પગલાંઓનું અન્વેષણ કરીએ છીએ અને રસ્તામાં સામાન્ય સમસ્યાઓનું નિવારણ કરીએ છીએ તેમ ટ્યુન રહો!

કોષ્ટકો બદલવા અને પંક્તિઓ અપડેટ કરવા માટે SQL સર્વર આદેશોને સમજવું

SQL સર્વર સાથે કામ કરતી વખતે, ખાસ કરીને મોટા ડેટાસેટ્સ ધરાવતા કોષ્ટકો સાથે, ટેબલ બદલવા અને તેની પંક્તિઓ અપડેટ કરવા માટે વ્યવસ્થિત અભિગમને અનુસરવું મહત્વપૂર્ણ છે. એક સામાન્ય દૃશ્ય માટે કોષ્ટકમાં નવી કૉલમ ઉમેરવાની અને પછી તારીખો પર આધારિત ધ્વજ સેટ કરવા જેવી ચોક્કસ શરતોના આધારે પંક્તિઓ અપડેટ કરવાની જરૂર છે. મેં આપેલી સ્ક્રિપ્ટ આ માટે એક સરળ અભિગમ દર્શાવે છે, પરંતુ તે કી SQL સર્વર આદેશોને હાઇલાઇટ કરે છે જે આ કાર્યોને અસરકારક રીતે હાંસલ કરવા માટે જરૂરી છે. આ ટેબલ બદલો આદેશનો ઉપયોગ ટેબલમાં નવી કૉલમ ઉમેરવા માટે થાય છે. દાખલા તરીકે, જ્યારે આપણે `ALTER TABLE dbo.sample AD 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 સર્વરમાં મોટા કોષ્ટકો સાથે કામ કરતી વખતે, ટેબલ સ્ટ્રક્ચરમાં ફેરફાર કરતી વખતે અને હાલની પંક્તિઓ અપડેટ કરતી વખતે પ્રદર્શન ઑપ્ટિમાઇઝેશન તકનીકોને ધ્યાનમાં લેવી મહત્વપૂર્ણ છે. મોટા કોષ્ટકો પર સ્ક્રિપ્ટો ચલાવતી વખતે સામનો કરવામાં આવતી સૌથી સામાન્ય સમસ્યાઓમાંની એક એ છે કે આ ઑપરેશન્સ પૂર્ણ થવામાં જે સમય લાગે છે, ખાસ કરીને જ્યારે કોષ્ટકમાં એક મિલિયનથી વધુ પંક્તિઓ હોય છે. પ્રશ્નમાંની કામગીરી, જેમ કે સાથે કૉલમ ઉમેરવી ટેબલ બદલો ચોક્કસ તારીખ શરતોના આધારે પંક્તિઓને આદેશ અને અપડેટ કરવામાં ઘણો સમય લાગી શકે છે. જ્યારે તમે પ્રોડક્શન ડેટાબેસેસ પર કામ કરી રહ્યા હોવ જ્યાં પરફોર્મન્સ પ્રાધાન્ય હોય ત્યારે આ ઑપરેશન્સને ઑપ્ટિમાઇઝ કરવાનું વધુ મહત્વનું બની જાય છે. એક જ સ્ક્રિપ્ટ ટેબલને વિસ્તૃત સમયગાળા માટે લૉક કરી શકે છે, અન્ય પ્રશ્નો અને વપરાશકર્તાઓને અસર કરે છે.

કામગીરીની સમસ્યાઓને હળવી કરવા માટે, એક શ્રેષ્ઠ અભિગમ એ છે કે કાર્યોને નાના પગલાઓમાં વિભાજિત કરવું. ઉદાહરણ તરીકે, એક જ સ્ક્રિપ્ટમાં કૉલમ ઉમેરવા અને બધી પંક્તિઓ અપડેટ કરવાને બદલે, ટેબલ બદલો અલગથી આદેશ, બેચિંગ દ્વારા અનુસરવામાં આવે છે UPDATE કામગીરી રેકોર્ડ્સને નાના હિસ્સામાં અપડેટ કરીને, સ્ક્રિપ્ટ સર્વરને ડૂબી જશે નહીં. તમે લાભ લઈ શકો છો UPDATE TOP દરેક વ્યવહારમાં અસરગ્રસ્ત પંક્તિઓની સંખ્યાને મર્યાદિત કરવાનો આદેશ. વધુમાં, તમારી WHERE કલમો (જેમ કે LOAD_DATE) શોધ પ્રક્રિયાને ઝડપી બનાવવા માટે. મોટા ડેટાસેટ્સ માટે, અનુક્રમણિકા તારીખ રેન્જના આધારે પંક્તિઓને ફિલ્ટર કરવામાં જે સમય લે છે તે ઘટાડે છે.

અન્ય મહત્વપૂર્ણ વિચારણા એ છે કે ઓપરેશન્સ પરમાણુ રીતે ચલાવવામાં આવે છે તેની ખાતરી કરવા માટે વ્યવહારો અને એરર હેન્ડલિંગનો ઉપયોગ. વીંટાળીને તમારા UPDATE અંદર નિવેદનો a BEGIN TRANSACTION અને COMMIT, તમે ખાતરી કરો છો કે ફેરફારો સલામત અને સુસંગત રીતે કરવામાં આવ્યા છે. જો પ્રક્રિયાનો કોઈપણ ભાગ નિષ્ફળ જાય, તો તમે ઉપયોગ કરી શકો છો ROLLBACK ફેરફારોને પાછું લાવવા માટે, આંશિક અપડેટ્સને અટકાવવા. વધુમાં, ઑફ-પીક કલાકો દરમિયાન સ્ક્રિપ્ટો ચલાવવાથી અથવા આ ઑપરેશન્સ શેડ્યૂલ કરવા માટે SQL સર્વર એજન્ટનો ઉપયોગ કરવાથી સિસ્ટમની કામગીરી પર ન્યૂનતમ અસર સુનિશ્ચિત થાય છે. આ ઑપ્ટિમાઇઝેશન સાથે, તમે સિસ્ટમની અખંડિતતા જાળવી રાખીને મોટા કોષ્ટકો પર જટિલ ફેરફારો સુરક્ષિત રીતે ચલાવી શકો છો. 🖥️