SQL ಸರ್ವರ್‌ನಲ್ಲಿ ಕಾಲಮ್ ಅನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಸೇರಿಸುವುದು ಮತ್ತು ಸಾಲುಗಳನ್ನು ನವೀಕರಿಸುವುದು ಹೇಗೆ

SQL ಸರ್ವರ್‌ನಲ್ಲಿ ಮಾಸ್ಟರಿಂಗ್ ಟೇಬಲ್ ಮಾರ್ಪಾಡುಗಳು: ಒಂದು ಹಂತ-ಹಂತದ ಮಾರ್ಗದರ್ಶಿ

ಕೆಲವೊಮ್ಮೆ, ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದು ಒಂದೇ ಬಾರಿಗೆ ನೂರು ಕಾರ್ಯಗಳನ್ನು ಕಣ್ಕಟ್ಟು ಮಾಡಲು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವಂತೆ ಭಾಸವಾಗುತ್ತದೆ. ಇತ್ತೀಚಿಗೆ, ಮಿಲಿಯನ್‌ಗಿಂತಲೂ ಹೆಚ್ಚು ಸಾಲುಗಳನ್ನು ಹೊಂದಿರುವ ಟೇಬಲ್‌ಗೆ ಕಾಲಮ್ ಅನ್ನು ಸೇರಿಸಬೇಕಾದ ಪರಿಸ್ಥಿತಿಯನ್ನು ನಾನು ಕಂಡುಕೊಂಡಿದ್ದೇನೆ. ಮೇಲ್ನೋಟಕ್ಕೆ ಇದು ಸರಳವಾದ ಕಾರ್ಯದಂತೆ ತೋರುತ್ತಿದ್ದರೂ, ಅನೇಕ SQL ಸರ್ವರ್ ಬಳಕೆದಾರರು ಎದುರಿಸುತ್ತಿರುವ ರಸ್ತೆ ತಡೆಗೆ ನಾನು ಬೇಗನೆ ಓಡಿದೆ: ಭಯಾನಕ "ಅಮಾನ್ಯ ಕಾಲಮ್ ಹೆಸರು" ದೋಷ. 🧐

ನನ್ನ ALTER TABLE ಮತ್ತು UPDATE ಕಮಾಂಡ್‌ಗಳನ್ನು ಒಟ್ಟಿಗೆ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಹಲವಾರು ಪ್ರಯತ್ನಗಳನ್ನು ನಡೆಸಿದ ನಂತರ, ಸಮಸ್ಯೆಯು ತರ್ಕದಿಂದಲ್ಲ ಆದರೆ ನನ್ನ ಪ್ರಶ್ನೆಗಳ ಅನುಕ್ರಮದಲ್ಲಿ ಎಂದು ನಾನು ಅರಿತುಕೊಂಡೆ. SQL ಸರ್ವರ್‌ಗೆ ನೀವು ಮೊದಲು ಕಾಲಮ್ ಅನ್ನು ಸೇರಿಸುವ ಅಗತ್ಯವಿದೆ ಮತ್ತು ಯಾವುದೇ ಡೇಟಾದೊಂದಿಗೆ ಅದನ್ನು ನವೀಕರಿಸುವ ಮೊದಲು ಬದಲಾವಣೆಯನ್ನು ಮಾಡುತ್ತೀರಿ. ಹಾಗೆ ಮಾಡಲು ವಿಫಲವಾದರೆ ದೋಷ ಉಂಟಾಗುತ್ತದೆ ಏಕೆಂದರೆ ನವೀಕರಣವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸಮಯದಲ್ಲಿ ಸಿಸ್ಟಂ ಹೊಸದಾಗಿ ಸೇರಿಸಲಾದ ಕಾಲಮ್ ಅನ್ನು ಗುರುತಿಸುವುದಿಲ್ಲ.

ಉದಾಹರಣೆಗೆ, ದೊಡ್ಡ ಗ್ರಾಹಕ ಡೇಟಾಬೇಸ್‌ಗಾಗಿ ನಿರ್ದಿಷ್ಟ ದಿನಾಂಕದ ಮಿತಿಯ ಆಧಾರದ ಮೇಲೆ "IS_CURRENT" ಫ್ಲ್ಯಾಗ್ ಅನ್ನು ನವೀಕರಿಸುವ ಕಾರ್ಯವನ್ನು ನೀವು ಹೊಂದಿದ್ದೀರಿ ಎಂದು ಊಹಿಸಿ. ನೀವು ಕಾಲಮ್ ಅನ್ನು ಸೇರಿಸಿದರೆ ಮತ್ತು ಸಾಲುಗಳನ್ನು ಒಂದೇ ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ನವೀಕರಿಸಲು ಪ್ರಯತ್ನಿಸಿದರೆ, SQL ಸರ್ವರ್ "ಅಮಾನ್ಯ ಕಾಲಮ್ ಹೆಸರು" ದೋಷವನ್ನು ಎಸೆಯಬಹುದು. ಏಕೆಂದರೆ ಅಪ್‌ಡೇಟ್ ಪ್ರಶ್ನೆಯು ಅದನ್ನು ಬಳಸಲು ಪ್ರಯತ್ನಿಸುವ ಮೊದಲು ಕಾಲಮ್ ಸಂಪೂರ್ಣವಾಗಿ ಬದ್ಧವಾಗಿಲ್ಲ. 🚀

ಈ ಲೇಖನದಲ್ಲಿ, ಕಾಲಮ್ ಅನ್ನು ಸೇರಿಸಲು ಮತ್ತು ಸಾಲುಗಳನ್ನು ನವೀಕರಿಸಲು ನಾವು ಸರಿಯಾದ ಅನುಕ್ರಮದ ಮೂಲಕ ನಡೆಯುತ್ತೇವೆ, ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳೊಂದಿಗೆ ಸುಗಮವಾದ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ಖಾತ್ರಿಪಡಿಸಿಕೊಳ್ಳುತ್ತೇವೆ. ಲಕ್ಷಾಂತರ ಸಾಲುಗಳನ್ನು ಸಮರ್ಥವಾಗಿ ನಿರ್ವಹಿಸಲು SQL ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡಲು ನಾವು ಸಲಹೆಗಳಿಗೆ ಧುಮುಕುತ್ತೇವೆ. ನಾವು ಹಂತಗಳನ್ನು ಎಕ್ಸ್‌ಪ್ಲೋರ್ ಮಾಡುವಾಗ ಮತ್ತು ದಾರಿಯುದ್ದಕ್ಕೂ ಸಾಮಾನ್ಯ ಸಮಸ್ಯೆಗಳನ್ನು ನಿವಾರಿಸುವಾಗ ಟ್ಯೂನ್ ಆಗಿರಿ!

ಟೇಬಲ್‌ಗಳನ್ನು ಬದಲಾಯಿಸಲು ಮತ್ತು ಸಾಲುಗಳನ್ನು ನವೀಕರಿಸಲು SQL ಸರ್ವರ್ ಆಜ್ಞೆಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

SQL ಸರ್ವರ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ, ವಿಶೇಷವಾಗಿ ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳನ್ನು ಹೊಂದಿರುವ ಕೋಷ್ಟಕಗಳೊಂದಿಗೆ, ಟೇಬಲ್ ಅನ್ನು ಬದಲಾಯಿಸಲು ಮತ್ತು ಅದರ ಸಾಲುಗಳನ್ನು ನವೀಕರಿಸಲು ಕ್ರಮಬದ್ಧವಾದ ವಿಧಾನವನ್ನು ಅನುಸರಿಸುವುದು ನಿರ್ಣಾಯಕವಾಗಿದೆ. ಒಂದು ಸಾಮಾನ್ಯ ಸನ್ನಿವೇಶವು ಟೇಬಲ್‌ಗೆ ಹೊಸ ಕಾಲಮ್ ಅನ್ನು ಸೇರಿಸುವ ಅಗತ್ಯವಿದೆ ಮತ್ತು ನಂತರ ದಿನಾಂಕಗಳ ಆಧಾರದ ಮೇಲೆ ಫ್ಲ್ಯಾಗ್ ಅನ್ನು ಹೊಂದಿಸುವಂತಹ ನಿರ್ದಿಷ್ಟ ಷರತ್ತುಗಳ ಆಧಾರದ ಮೇಲೆ ಸಾಲುಗಳನ್ನು ನವೀಕರಿಸಬೇಕಾಗುತ್ತದೆ. ನಾನು ಒದಗಿಸಿದ ಸ್ಕ್ರಿಪ್ಟ್ ಇದಕ್ಕೆ ಸರಳವಾದ ವಿಧಾನವನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ, ಆದರೆ ಈ ಕಾರ್ಯಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಸಾಧಿಸಲು ಅಗತ್ಯವಾದ ಪ್ರಮುಖ SQL ಸರ್ವರ್ ಆಜ್ಞೆಗಳನ್ನು ಇದು ಹೈಲೈಟ್ ಮಾಡುತ್ತದೆ. ದಿ ಆಲ್ಟರ್ ಟೇಬಲ್ ಟೇಬಲ್‌ಗೆ ಹೊಸ ಕಾಲಮ್ ಅನ್ನು ಸೇರಿಸಲು ಆಜ್ಞೆಯನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ನಾವು `ALTER TABLE dbo.sample ADD IS_CURRENT BIT;` ಅನ್ನು ರನ್ ಮಾಡಿದಾಗ, `BIT` ಪ್ರಕಾರದ `IS_CURRENT` ಹೆಸರಿನ ಹೊಸ ಕಾಲಮ್ ಅನ್ನು ಪರಿಚಯಿಸಲು ನಾವು ಟೇಬಲ್ ರಚನೆಯನ್ನು ಮಾರ್ಪಡಿಸುತ್ತಿದ್ದೇವೆ (ಬೂಲಿಯನ್ ಪ್ರಕಾರ, 0 ಅಥವಾ 1).

ಕಾಲಮ್ ಅನ್ನು ಸೇರಿಸಿದ ನಂತರ, ಮುಂದಿನ ಹಂತವು ಕೆಲವು ಷರತ್ತುಗಳ ಆಧಾರದ ಮೇಲೆ ಕೋಷ್ಟಕದಲ್ಲಿನ ಸಾಲುಗಳನ್ನು ನವೀಕರಿಸುವುದು. ಇದನ್ನು ಬಳಸಿಕೊಂಡು ಸಾಧಿಸಲಾಗುತ್ತದೆ ನವೀಕರಿಸಿ ಆಜ್ಞೆ. ಉದಾಹರಣೆಗೆ, ಪ್ರಶ್ನೆ `UPDATE dbo.sample SET IS_CURRENT = 0 WHERE LOAD_DATE

ಕೆಲವು ಸಂದರ್ಭಗಳಲ್ಲಿ, ವಿಶೇಷವಾಗಿ ಲಕ್ಷಾಂತರ ಸಾಲುಗಳನ್ನು ಹೊಂದಿರುವ ದೊಡ್ಡ ಕೋಷ್ಟಕಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ, SQL ಆಜ್ಞೆಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು ಮುಖ್ಯವಾಗಿದೆ. ಈ ರೀತಿಯ ಕಾರ್ಯಗಳು ಇಲ್ಲಿವೆ DATEADD ಮತ್ತು ದಿನಾಂಕDIFF ಆಟಕ್ಕೆ ಬನ್ನಿ. ಈ ಕಾರ್ಯಗಳು ನಿಖರವಾಗಿ ದಿನಾಂಕಗಳನ್ನು ಕುಶಲತೆಯಿಂದ ಮತ್ತು ಹೋಲಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಎರಡನೇ ಅಪ್‌ಡೇಟ್ ಪ್ರಶ್ನೆಯಲ್ಲಿ, `DATEADD(ತಿಂಗಳು, DATEDIFF(ತಿಂಗಳು, 0, DATEADD(DAY, -60, GETDATE())), 0)` ಪ್ರಸ್ತುತ ದಿನಾಂಕದಿಂದ (`GETDATE()`) 60 ದಿನಗಳನ್ನು ಕಳೆಯುತ್ತದೆ ಮತ್ತು ಮರುಹೊಂದಿಸುತ್ತದೆ ತಿಂಗಳ ಆರಂಭದ ಸಮಯ. ಈ ಕಾರ್ಯಗಳನ್ನು ಬಳಸುವ ಮೂಲಕ, ಸಮಯ ಮುಂದುವರೆದಂತೆ ಸರಿಹೊಂದಿಸುವ ಹೆಚ್ಚು ಕ್ರಿಯಾತ್ಮಕ ದಿನಾಂಕ ಶ್ರೇಣಿಗಳನ್ನು ನಾವು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು, ಡೇಟಾವು ವಯಸ್ಸಾದಾಗಲೂ ಪ್ರಸ್ತುತವಾಗಿರುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬಹುದು.

ಆದಾಗ್ಯೂ, ಒಂದೇ ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ `ಆಲ್ಟರ್ ಟೇಬಲ್` ಮತ್ತು `ಅಪ್‌ಡೇಟ್` ಎರಡೂ ಹೇಳಿಕೆಗಳನ್ನು ಸಂಯೋಜಿಸುವಾಗ, 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 ಎ ಒಳಗೆ ಹೇಳಿಕೆಗಳು BEGIN TRANSACTION ಮತ್ತು COMMIT, ಬದಲಾವಣೆಗಳನ್ನು ಸುರಕ್ಷಿತ ಮತ್ತು ಸ್ಥಿರ ರೀತಿಯಲ್ಲಿ ಮಾಡಲಾಗಿದೆ ಎಂದು ನೀವು ಖಚಿತಪಡಿಸುತ್ತೀರಿ. ಪ್ರಕ್ರಿಯೆಯ ಯಾವುದೇ ಭಾಗವು ವಿಫಲವಾದರೆ, ನೀವು ಬಳಸಬಹುದು ROLLBACK ಬದಲಾವಣೆಗಳನ್ನು ಹಿಂತಿರುಗಿಸಲು, ಭಾಗಶಃ ನವೀಕರಣಗಳನ್ನು ತಡೆಯುತ್ತದೆ. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಆಫ್-ಪೀಕ್ ಸಮಯದಲ್ಲಿ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಚಲಾಯಿಸುವುದು ಅಥವಾ ಈ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿಗದಿಪಡಿಸಲು SQL ಸರ್ವರ್ ಏಜೆಂಟ್ ಅನ್ನು ಬಳಸುವುದು ಸಿಸ್ಟಮ್ ಕಾರ್ಯಕ್ಷಮತೆಯ ಮೇಲೆ ಕನಿಷ್ಠ ಪರಿಣಾಮವನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಈ ಆಪ್ಟಿಮೈಸೇಶನ್‌ಗಳೊಂದಿಗೆ, ಸಿಸ್ಟಮ್ ಸಮಗ್ರತೆಯನ್ನು ಕಾಪಾಡಿಕೊಳ್ಳುವಾಗ ನೀವು ದೊಡ್ಡ ಕೋಷ್ಟಕಗಳಲ್ಲಿ ಸಂಕೀರ್ಣ ಮಾರ್ಪಾಡುಗಳನ್ನು ಸುರಕ್ಷಿತವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು. 🖥️