SQL ਸਰਵਰ ਵਿੱਚ ਇੱਕ ਕਾਲਮ ਅਤੇ ਅੱਪਡੇਟ ਕਤਾਰਾਂ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਕਿਵੇਂ ਜੋੜਿਆ ਜਾਵੇ

SQL ਸਰਵਰ ਵਿੱਚ ਮਾਸਟਰਿੰਗ ਟੇਬਲ ਸੋਧ: ਇੱਕ ਕਦਮ-ਦਰ-ਕਦਮ ਗਾਈਡ

ਕਈ ਵਾਰ, ਵੱਡੇ ਡੇਟਾਸੈਟਾਂ ਨਾਲ ਕੰਮ ਕਰਨਾ ਇੱਕ ਵਾਰ ਵਿੱਚ ਸੌ ਕਾਰਜਾਂ ਨੂੰ ਜੁਗਲ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਵਾਂਗ ਮਹਿਸੂਸ ਕਰ ਸਕਦਾ ਹੈ। ਹਾਲ ਹੀ ਵਿੱਚ, ਮੈਂ ਆਪਣੇ ਆਪ ਨੂੰ ਅਜਿਹੀ ਸਥਿਤੀ ਵਿੱਚ ਪਾਇਆ ਜਿੱਥੇ ਮੈਨੂੰ ਇੱਕ ਮਿਲੀਅਨ ਤੋਂ ਵੱਧ ਕਤਾਰਾਂ ਵਾਲੀ ਇੱਕ ਸਾਰਣੀ ਵਿੱਚ ਇੱਕ ਕਾਲਮ ਜੋੜਨ ਦੀ ਲੋੜ ਸੀ। ਹਾਲਾਂਕਿ ਇਹ ਸਤ੍ਹਾ 'ਤੇ ਇੱਕ ਸਧਾਰਨ ਕੰਮ ਦੀ ਤਰ੍ਹਾਂ ਜਾਪਦਾ ਸੀ, ਮੈਂ ਤੇਜ਼ੀ ਨਾਲ ਇੱਕ ਰੋਡਬੌਕ ਵਿੱਚ ਭੱਜਿਆ ਜਿਸਦਾ ਬਹੁਤ ਸਾਰੇ SQL ਸਰਵਰ ਉਪਭੋਗਤਾ ਸਾਹਮਣਾ ਕਰਦੇ ਹਨ: ਭਿਆਨਕ "ਅਵੈਧ ਕਾਲਮ ਨਾਮ" ਗਲਤੀ। 🧐

ਮੇਰੇ ALTER ਟੇਬਲ ਅਤੇ ਅੱਪਡੇਟ ਕਮਾਂਡਾਂ ਨੂੰ ਇਕੱਠੇ ਚਲਾਉਣ ਲਈ ਕਈ ਕੋਸ਼ਿਸ਼ਾਂ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਮੈਨੂੰ ਅਹਿਸਾਸ ਹੋਇਆ ਕਿ ਸਮੱਸਿਆ ਤਰਕ ਨਾਲ ਨਹੀਂ ਸੀ, ਪਰ ਮੇਰੇ ਸਵਾਲਾਂ ਦੇ ਕ੍ਰਮ ਨਾਲ ਸੀ। SQL ਸਰਵਰ ਲਈ ਲੋੜ ਹੈ ਕਿ ਤੁਸੀਂ ਪਹਿਲਾਂ ਕਾਲਮ ਜੋੜੋ ਅਤੇ ਕਿਸੇ ਵੀ ਡੇਟਾ ਨਾਲ ਇਸਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਉਸ ਤਬਦੀਲੀ ਨੂੰ ਕਰੋ। ਅਜਿਹਾ ਕਰਨ ਵਿੱਚ ਅਸਫਲ ਰਹਿਣ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਇੱਕ ਗਲਤੀ ਹੁੰਦੀ ਹੈ ਕਿਉਂਕਿ ਸਿਸਟਮ ਅੱਪਡੇਟ ਦੇ ਐਗਜ਼ੀਕਿਊਟ ਹੋਣ ਸਮੇਂ ਨਵੇਂ ਸ਼ਾਮਲ ਕੀਤੇ ਕਾਲਮ ਨੂੰ ਨਹੀਂ ਪਛਾਣਦਾ ਹੈ।

ਉਦਾਹਰਨ ਲਈ, ਕਲਪਨਾ ਕਰੋ ਕਿ ਤੁਹਾਨੂੰ ਇੱਕ ਵੱਡੇ ਗਾਹਕ ਡੇਟਾਬੇਸ ਲਈ ਇੱਕ ਖਾਸ ਮਿਤੀ ਥ੍ਰੈਸ਼ਹੋਲਡ ਦੇ ਅਧਾਰ ਤੇ "IS_CURRENT" ਫਲੈਗ ਨੂੰ ਅਪਡੇਟ ਕਰਨ ਦਾ ਕੰਮ ਸੌਂਪਿਆ ਗਿਆ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਕਾਲਮ ਜੋੜਦੇ ਹੋ ਅਤੇ ਇੱਕ ਸਿੰਗਲ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਕਤਾਰਾਂ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹੋ, ਤਾਂ SQL ਸਰਵਰ ਇੱਕ "ਅਵੈਧ ਕਾਲਮ ਨਾਮ" ਗਲਤੀ ਸੁੱਟ ਸਕਦਾ ਹੈ। ਇਹ ਇਸ ਲਈ ਹੈ ਕਿਉਂਕਿ ਅੱਪਡੇਟ ਪੁੱਛਗਿੱਛ ਇਸਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਕਾਲਮ ਪੂਰੀ ਤਰ੍ਹਾਂ ਪ੍ਰਤੀਬੱਧ ਨਹੀਂ ਹੈ। 🚀

ਇਸ ਲੇਖ ਵਿੱਚ, ਅਸੀਂ ਕਾਲਮ ਨੂੰ ਜੋੜਨ ਅਤੇ ਕਤਾਰਾਂ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਲਈ ਸਹੀ ਕ੍ਰਮ ਵਿੱਚ ਚੱਲਾਂਗੇ, ਵੱਡੇ ਡੇਟਾਸੈਟਾਂ ਦੇ ਨਾਲ ਵੀ ਨਿਰਵਿਘਨ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦੇ ਹੋਏ। ਅਸੀਂ ਲੱਖਾਂ ਕਤਾਰਾਂ ਨੂੰ ਕੁਸ਼ਲਤਾ ਨਾਲ ਹੈਂਡਲ ਕਰਨ ਲਈ SQL ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਲਈ ਸੁਝਾਵਾਂ ਵਿੱਚ ਵੀ ਡੁਬਕੀ ਲਗਾਵਾਂਗੇ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ ਤੁਹਾਡੇ ਡੇਟਾ ਓਪਰੇਸ਼ਨ ਬਿਨਾਂ ਕਿਸੇ ਰੁਕਾਵਟ ਦੇ ਚੱਲਦੇ ਹਨ। ਸਾਡੇ ਨਾਲ ਜੁੜੇ ਰਹੋ ਕਿਉਂਕਿ ਅਸੀਂ ਕਦਮਾਂ ਦੀ ਪੜਚੋਲ ਕਰਦੇ ਹਾਂ ਅਤੇ ਰਸਤੇ ਵਿੱਚ ਆਮ ਸਮੱਸਿਆਵਾਂ ਦਾ ਨਿਪਟਾਰਾ ਕਰਦੇ ਹਾਂ!

ਹੁਕਮ	ਵਰਤੋਂ ਦੀ ਉਦਾਹਰਨ
ALTER TABLE	ਇਹ ਕਮਾਂਡ ਮੌਜੂਦਾ ਟੇਬਲ ਦੀ ਬਣਤਰ ਨੂੰ ਸੋਧਣ ਲਈ ਵਰਤੀ ਜਾਂਦੀ ਹੈ, ਜਿਵੇਂ ਕਿ ਨਵੇਂ ਕਾਲਮ ਜੋੜਨਾ। ਉਦਾਹਰਨ ਲਈ, `ALTER TABLE dbo.sample ADD IS_CURRENT BIT;` `dbo.sample` ਸਾਰਣੀ ਵਿੱਚ `IS_CURRENT` ਨਾਮਕ ਇੱਕ ਨਵਾਂ ਕਾਲਮ ਜੋੜਦਾ ਹੈ।
UPDATE	'ਅੱਪਡੇਟ' ਕਮਾਂਡ ਦੀ ਵਰਤੋਂ ਸਾਰਣੀ ਵਿੱਚ ਮੌਜੂਦਾ ਰਿਕਾਰਡਾਂ ਨੂੰ ਸੋਧਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਉਦਾਹਰਨ ਲਈ, `UPDATE dbo.sample SET IS_CURRENT = 0 WHERE LOAD_DATE
CAST	SQL ਸਰਵਰ ਵਿੱਚ, `CAST` ਦੀ ਵਰਤੋਂ ਇੱਕ ਡਾਟਾ ਕਿਸਮ ਨੂੰ ਦੂਜੀ ਵਿੱਚ ਬਦਲਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਉਦਾਹਰਨ ਵਿੱਚ, `CAST(DATEADD(ਮਹੀਨਾ, DATEDIFF(ਮਹੀਨਾ, 0, DATEADD(DAY, -60, GETDATE())), 0) AS DATE)` ਇੱਕ ਮਿਤੀ ਹੇਰਾਫੇਰੀ ਨਤੀਜੇ ਨੂੰ ਇੱਕ ਮਿਤੀ ਕਿਸਮ ਵਿੱਚ ਬਦਲਦਾ ਹੈ।
DATEADD	ਇਹ ਫੰਕਸ਼ਨ ਇੱਕ ਮਿਤੀ ਵਿੱਚ ਇੱਕ ਖਾਸ ਸਮਾਂ ਅੰਤਰਾਲ ਜੋੜਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, `DATEADD(DAY, -60, GETDATE())` ਮੌਜੂਦਾ ਮਿਤੀ ਤੋਂ 60 ਦਿਨਾਂ ਨੂੰ ਘਟਾਉਂਦਾ ਹੈ।
DATEDIFF	`DATEDIFF` ਫੰਕਸ਼ਨ ਦੋ ਤਾਰੀਖਾਂ ਵਿਚਕਾਰ ਅੰਤਰ ਦੀ ਗਣਨਾ ਕਰਦਾ ਹੈ। ਇਸ ਸਥਿਤੀ ਵਿੱਚ, `DATEDIFF(ਮਹੀਨਾ, 0, GETDATE())` ਅਧਾਰ ਮਿਤੀ (0, ਜੋ ਕਿ '1900-01-01' ਹੈ) ਅਤੇ ਮੌਜੂਦਾ ਮਿਤੀ ਦੇ ਵਿਚਕਾਰ ਮਹੀਨਿਆਂ ਦੀ ਸੰਖਿਆ ਲੱਭਦਾ ਹੈ।
BEGIN TRANSACTION	ਇਹ ਕਮਾਂਡ ਇੱਕ ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਬਲਾਕ ਸ਼ੁਰੂ ਕਰਦੀ ਹੈ। ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ ਕਿ ਇੱਕ ਤੋਂ ਵੱਧ SQL ਸਟੇਟਮੈਂਟਾਂ ਨੂੰ ਇੱਕ ਇਕਾਈ ਦੇ ਤੌਰ 'ਤੇ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਹੈ, ਡੇਟਾ ਦੀ ਇਕਸਾਰਤਾ ਨੂੰ ਕਾਇਮ ਰੱਖਦੇ ਹੋਏ। `BEGIN TRANSACTION;` ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ, ਅਤੇ ਕੋਈ ਵੀ ਤਬਦੀਲੀ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ ਜਾਂ ਵਾਪਸ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।
COMMIT TRANSACTION	ਡੇਟਾਬੇਸ ਵਿੱਚ ਲੈਣ-ਦੇਣ ਦੌਰਾਨ ਕੀਤੀਆਂ ਸਾਰੀਆਂ ਤਬਦੀਲੀਆਂ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। `ਕਮਿਟ ਟ੍ਰਾਂਜੈਕਸ਼ਨ;` ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ `ਸ਼ੁਰੂ ਟ੍ਰਾਂਜੈਕਸ਼ਨ` ਬਲਾਕ ਦੇ ਅੰਦਰ ਕੀਤੀਆਂ ਸਾਰੀਆਂ ਤਬਦੀਲੀਆਂ ਨੂੰ ਅੰਤਿਮ ਰੂਪ ਦਿੱਤਾ ਗਿਆ ਹੈ ਅਤੇ ਜਾਰੀ ਰਹੇਗਾ।
UPDATE TOP	'UPDATE' ਕਮਾਂਡ ਦਾ ਇਹ ਸੰਸਕਰਣ ਅਪਡੇਟ ਦੁਆਰਾ ਪ੍ਰਭਾਵਿਤ ਕਤਾਰਾਂ ਦੀ ਸੰਖਿਆ ਨੂੰ ਸੀਮਿਤ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, `UPDATE TOP (10000) dbo.sample SET IS_CURRENT = 0 WHERE LOAD_DATE
EXEC msdb.dbo.sp_add_job	ਇਹ ਸਟੋਰ ਕੀਤੀ ਵਿਧੀ SQL ਸਰਵਰ ਏਜੰਟ ਵਿੱਚ ਨਵੀਂ ਨੌਕਰੀ ਬਣਾਉਣ ਲਈ ਵਰਤੀ ਜਾਂਦੀ ਹੈ। `EXEC msdb.dbo.sp_add_job @job_name = 'IS_CURRENT ਜੌਬ ਅੱਪਡੇਟ ਕਰੋ';` ਇੱਕ ਅਜਿਹੀ ਨੌਕਰੀ ਬਣਾਉਂਦਾ ਹੈ ਜੋ ਖਾਸ 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(ਮਹੀਨਾ, 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 ਸਰਵਰ ਵਿੱਚ ਵੱਡੀਆਂ ਟੇਬਲਾਂ ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ, ਸਾਰਣੀ ਦੇ ਢਾਂਚੇ ਨੂੰ ਬਦਲਦੇ ਹੋਏ ਅਤੇ ਮੌਜੂਦਾ ਕਤਾਰਾਂ ਨੂੰ ਅੱਪਡੇਟ ਕਰਦੇ ਸਮੇਂ ਕਾਰਗੁਜ਼ਾਰੀ ਅਨੁਕੂਲਨ ਤਕਨੀਕਾਂ 'ਤੇ ਵਿਚਾਰ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੁੰਦਾ ਹੈ। ਵੱਡੀਆਂ ਟੇਬਲਾਂ 'ਤੇ ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਚਲਾਉਣ ਵੇਲੇ ਸਭ ਤੋਂ ਆਮ ਸਮੱਸਿਆਵਾਂ ਵਿੱਚੋਂ ਇੱਕ ਇਹ ਹੈ ਕਿ ਇਹਨਾਂ ਕਾਰਵਾਈਆਂ ਨੂੰ ਪੂਰਾ ਹੋਣ ਵਿੱਚ ਸਮਾਂ ਲੱਗਦਾ ਹੈ, ਖਾਸ ਕਰਕੇ ਜਦੋਂ ਇੱਕ ਸਾਰਣੀ ਵਿੱਚ ਇੱਕ ਮਿਲੀਅਨ ਤੋਂ ਵੱਧ ਕਤਾਰਾਂ ਹੁੰਦੀਆਂ ਹਨ। ਸਵਾਲ ਵਿੱਚ ਕਾਰਵਾਈਆਂ, ਜਿਵੇਂ ਕਿ ਨਾਲ ਇੱਕ ਕਾਲਮ ਜੋੜਨਾ ਖਾਸ ਮਿਤੀ ਸ਼ਰਤਾਂ ਦੇ ਆਧਾਰ 'ਤੇ ਕਮਾਂਡ ਅਤੇ ਕਤਾਰਾਂ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨਾ, ਕਾਫ਼ੀ ਸਮਾਂ ਲੈ ਸਕਦਾ ਹੈ। ਇਹਨਾਂ ਓਪਰੇਸ਼ਨਾਂ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣਾ ਹੋਰ ਵੀ ਮਹੱਤਵਪੂਰਨ ਹੋ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਤੁਸੀਂ ਉਤਪਾਦਨ ਡੇਟਾਬੇਸ 'ਤੇ ਕੰਮ ਕਰ ਰਹੇ ਹੁੰਦੇ ਹੋ ਜਿੱਥੇ ਪ੍ਰਦਰਸ਼ਨ ਨੂੰ ਤਰਜੀਹ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ। ਇੱਕ ਸਿੰਗਲ ਸਕ੍ਰਿਪਟ ਸੰਭਾਵੀ ਤੌਰ 'ਤੇ ਵਿਸਤ੍ਰਿਤ ਸਮੇਂ ਲਈ ਸਾਰਣੀ ਨੂੰ ਲਾਕ ਕਰ ਸਕਦੀ ਹੈ, ਹੋਰ ਸਵਾਲਾਂ ਅਤੇ ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਦੀ ਹੈ।

ਪ੍ਰਦਰਸ਼ਨ ਦੇ ਮੁੱਦਿਆਂ ਨੂੰ ਘਟਾਉਣ ਲਈ, ਸਭ ਤੋਂ ਵਧੀਆ ਪਹੁੰਚਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ ਕੰਮਾਂ ਨੂੰ ਛੋਟੇ ਕਦਮਾਂ ਵਿੱਚ ਵੰਡਣਾ। ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਕਾਲਮ ਜੋੜਨ ਅਤੇ ਇੱਕ ਸਿੰਗਲ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਸਾਰੀਆਂ ਕਤਾਰਾਂ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਦੀ ਬਜਾਏ, ਨੂੰ ਚਲਾਉਣ 'ਤੇ ਵਿਚਾਰ ਕਰੋ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਕਮਾਂਡ, ਬੈਚਿੰਗ ਦੇ ਬਾਅਦ ਓਪਰੇਸ਼ਨ ਰਿਕਾਰਡਾਂ ਨੂੰ ਛੋਟੇ ਹਿੱਸਿਆਂ ਵਿੱਚ ਅੱਪਡੇਟ ਕਰਨ ਨਾਲ, ਸਕ੍ਰਿਪਟ ਸਰਵਰ ਨੂੰ ਹਾਵੀ ਨਹੀਂ ਕਰੇਗੀ। ਦਾ ਲਾਭ ਉਠਾ ਸਕਦੇ ਹੋ ਹਰੇਕ ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਵਿੱਚ ਪ੍ਰਭਾਵਿਤ ਕਤਾਰਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਸੀਮਿਤ ਕਰਨ ਲਈ ਕਮਾਂਡ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਤੁਹਾਡੇ ਵਿੱਚ ਵਰਤੇ ਗਏ ਕਾਲਮਾਂ 'ਤੇ ਸੂਚਕਾਂਕ ਬਣਾਉਣਾ ਵੀ ਇੱਕ ਚੰਗਾ ਵਿਚਾਰ ਹੈ WHERE ਧਾਰਾਵਾਂ (ਜਿਵੇਂ ਕਿ ) ਖੋਜ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਤੇਜ਼ ਕਰਨ ਲਈ. ਵੱਡੇ ਡੇਟਾਸੈਟਾਂ ਲਈ, ਸੂਚਕਾਂਕ ਮਿਤੀ ਰੇਂਜਾਂ ਦੇ ਆਧਾਰ 'ਤੇ ਕਤਾਰਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰਨ ਲਈ ਲੱਗਣ ਵਾਲੇ ਸਮੇਂ ਨੂੰ ਘਟਾਉਂਦੇ ਹਨ।

ਇੱਕ ਹੋਰ ਮਹੱਤਵਪੂਰਨ ਵਿਚਾਰ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ ਓਪਰੇਸ਼ਨ ਪ੍ਰਮਾਣੂ ਢੰਗ ਨਾਲ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ, ਲੈਣ-ਦੇਣ ਅਤੇ ਗਲਤੀ ਨਾਲ ਨਜਿੱਠਣ ਦੀ ਵਰਤੋਂ ਹੈ। ਆਪਣੇ ਲਪੇਟ ਕੇ ਅੰਦਰ ਬਿਆਨ ਏ ਅਤੇ , ਤੁਸੀਂ ਯਕੀਨੀ ਬਣਾਉਂਦੇ ਹੋ ਕਿ ਤਬਦੀਲੀਆਂ ਸੁਰੱਖਿਅਤ ਅਤੇ ਇਕਸਾਰ ਤਰੀਕੇ ਨਾਲ ਕੀਤੀਆਂ ਗਈਆਂ ਹਨ। ਜੇ ਪ੍ਰਕਿਰਿਆ ਦਾ ਕੋਈ ਹਿੱਸਾ ਅਸਫਲ ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਵਰਤ ਸਕਦੇ ਹੋ ROLLBACK ਤਬਦੀਲੀਆਂ ਨੂੰ ਵਾਪਸ ਕਰਨ ਲਈ, ਅੰਸ਼ਕ ਅੱਪਡੇਟਾਂ ਨੂੰ ਰੋਕਣ ਲਈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਔਫ-ਪੀਕ ਘੰਟਿਆਂ ਦੌਰਾਨ ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਚਲਾਉਣਾ ਜਾਂ ਇਹਨਾਂ ਓਪਰੇਸ਼ਨਾਂ ਨੂੰ ਤਹਿ ਕਰਨ ਲਈ SQL ਸਰਵਰ ਏਜੰਟ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਸਿਸਟਮ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ 'ਤੇ ਘੱਟੋ ਘੱਟ ਪ੍ਰਭਾਵ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ। ਇਹਨਾਂ ਅਨੁਕੂਲਤਾਵਾਂ ਦੇ ਨਾਲ, ਤੁਸੀਂ ਸਿਸਟਮ ਦੀ ਇਕਸਾਰਤਾ ਨੂੰ ਕਾਇਮ ਰੱਖਦੇ ਹੋਏ ਵੱਡੇ ਟੇਬਲਾਂ 'ਤੇ ਗੁੰਝਲਦਾਰ ਸੋਧਾਂ ਨੂੰ ਸੁਰੱਖਿਅਤ ਢੰਗ ਨਾਲ ਚਲਾ ਸਕਦੇ ਹੋ। 🖥️

1. ਮੈਂ SQL ਸਰਵਰ ਵਿੱਚ ਇੱਕ ਸਾਰਣੀ ਵਿੱਚ ਇੱਕ ਨਵਾਂ ਕਾਲਮ ਕਿਵੇਂ ਜੋੜਾਂ?
2. ਤੁਸੀਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਨਵਾਂ ਕਾਲਮ ਜੋੜ ਸਕਦੇ ਹੋ ਹੁਕਮ. ਉਦਾਹਰਨ ਲਈ: ALTER TABLE dbo.sample ADD IS_CURRENT BIT; BIT ਦੀ ਇੱਕ ਡਾਟਾ ਕਿਸਮ ਦੇ ਨਾਲ IS_CURRENT ਨਾਮ ਦਾ ਇੱਕ ਕਾਲਮ ਜੋੜਦਾ ਹੈ।
3. ਮੈਂ SQL ਸਰਵਰ ਵਿੱਚ ਕਤਾਰਾਂ ਦੀ ਸਿਰਫ਼ ਇੱਕ ਖਾਸ ਰੇਂਜ ਨੂੰ ਕਿਵੇਂ ਅੱਪਡੇਟ ਕਰ ਸਕਦਾ ਹਾਂ?
4. ਦੀ ਵਰਤੋਂ ਕਰੋ ਇੱਕ ਨਾਲ ਹੁਕਮ ਕਤਾਰਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰਨ ਲਈ ਧਾਰਾ। ਉਦਾਹਰਨ ਲਈ: ਅੱਪਡੇਟ dbo.sample SET IS_CURRENT = 0 WHERE LOAD_DATE
5. ਮੇਰੀ ਸਕ੍ਰਿਪਟ "ਅਵੈਧ ਕਾਲਮ ਨਾਮ" ਗਲਤੀ ਕਿਉਂ ਸੁੱਟਦੀ ਹੈ?
6. ਇਹ ਗਲਤੀ ਹੁੰਦੀ ਹੈ ਜੇਕਰ ਨੂੰ ਚਲਾਉਣ ਤੋਂ ਪਹਿਲਾਂ ਕਮਾਂਡ ਪੂਰੀ ਤਰ੍ਹਾਂ ਪ੍ਰਤੀਬੱਧ ਨਹੀਂ ਹੈ ਬਿਆਨ. ਇਸ ਤੋਂ ਬਚਣ ਲਈ, ਚਲਾਓ ਪਹਿਲਾਂ ਕਮਾਂਡ, ਕਾਲਮ ਨੂੰ ਜੋੜਨ ਦੀ ਉਡੀਕ ਕਰੋ, ਫਿਰ ਚਲਾਓ UPDATE ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਸਵਾਲ.
7. ਪ੍ਰਦਰਸ਼ਨ ਨੂੰ ਬਿਹਤਰ ਬਣਾਉਣ ਲਈ ਮੈਂ ਬੈਚਾਂ ਵਿੱਚ ਕਤਾਰਾਂ ਨੂੰ ਕਿਵੇਂ ਅੱਪਡੇਟ ਕਰ ਸਕਦਾ ਹਾਂ?
8. ਦੀ ਵਰਤੋਂ ਕਰੋ ਇੱਕ ਵਾਰ ਵਿੱਚ ਅਪਡੇਟ ਕੀਤੀਆਂ ਕਤਾਰਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਸੀਮਿਤ ਕਰਨ ਲਈ ਕਮਾਂਡ. ਉਦਾਹਰਨ ਲਈ: ਅੱਪਡੇਟ TOP (1000) dbo.sample SET IS_CURRENT = 0 WHERE LOAD_DATE
9. ਕੀ ਮੈਂ ਪਰਮਾਣੂ ਅਪਡੇਟਾਂ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਇੱਕ ਲੈਣ-ਦੇਣ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦਾ ਹਾਂ?
10. ਹਾਂ! ਆਪਣੇ ਲਪੇਟ ਇੱਕ ਵਿੱਚ ਬਿਆਨ ਅਤੇ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਬਲਾਕ ਕਰੋ ਕਿ ਸਾਰੇ ਅੱਪਡੇਟ ਇੱਕ ਸਿੰਗਲ ਯੂਨਿਟ ਵਜੋਂ ਲਾਗੂ ਕੀਤੇ ਗਏ ਹਨ। ਜੇਕਰ ਕੋਈ ਗਲਤੀ ਹੁੰਦੀ ਹੈ, ਵਰਤੋ ROLLBACK ਤਬਦੀਲੀਆਂ ਨੂੰ ਅਨਡੂ ਕਰਨ ਲਈ।
11. SQL ਸਰਵਰ ਵਿੱਚ ਵੱਡੇ ਅੱਪਡੇਟਾਂ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਦਾ ਸਭ ਤੋਂ ਵਧੀਆ ਤਰੀਕਾ ਕੀ ਹੈ?
12. ਅੱਪਡੇਟ ਨੂੰ ਛੋਟੇ ਹਿੱਸਿਆਂ ਵਿੱਚ ਵੰਡਣ, ਸੰਬੰਧਿਤ ਕਾਲਮਾਂ 'ਤੇ ਸੂਚਕਾਂਕ ਬਣਾਉਣ, ਅਤੇ ਔਫ-ਪੀਕ ਘੰਟਿਆਂ ਦੌਰਾਨ ਸਕ੍ਰਿਪਟ ਨੂੰ ਚਲਾਉਣ 'ਤੇ ਵਿਚਾਰ ਕਰੋ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਵਿਧੀ ਲਾਕਿੰਗ ਮੁੱਦਿਆਂ ਤੋਂ ਬਚਣ ਵਿੱਚ ਮਦਦ ਕਰਦੀ ਹੈ ਅਤੇ ਸਰੋਤ ਦੀ ਖਪਤ ਨੂੰ ਘਟਾਉਂਦੀ ਹੈ।
13. ਮੈਂ SQL ਸਰਵਰ ਵਿੱਚ ਤਾਰੀਖ ਦੀ ਤੁਲਨਾ ਨੂੰ ਹੋਰ ਗਤੀਸ਼ੀਲ ਕਿਵੇਂ ਬਣਾ ਸਕਦਾ ਹਾਂ?
14. ਮਿਤੀ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ ਜਿਵੇਂ ਕਿ ਅਤੇ ਗਤੀਸ਼ੀਲ ਮਿਤੀ ਗਣਨਾ ਕਰਨ ਲਈ. ਉਦਾਹਰਨ ਲਈ, 60 ਦਿਨ ਪਹਿਲਾਂ ਦੀ ਤਾਰੀਖ ਸੈੱਟ ਕਰਨ ਲਈ, DATEADD(DAY, -60, GETDATE()) ਦੀ ਵਰਤੋਂ ਕਰੋ।
15. ਮੈਨੂੰ ਕੀ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ ਜੇਕਰ ਮੈਨੂੰ ਇੱਕ ਮਿਤੀ ਦੇ ਆਧਾਰ 'ਤੇ ਲੱਖਾਂ ਕਤਾਰਾਂ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਦੀ ਲੋੜ ਹੈ?
16. ਬਿਹਤਰ ਪ੍ਰਦਰਸ਼ਨ ਲਈ ਇੰਡੈਕਸਡ ਕਾਲਮਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ 'ਤੇ ਵਿਚਾਰ ਕਰੋ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਆਪਣੇ ਅੱਪਡੇਟ ਨੂੰ ਛੋਟੇ ਲੈਣ-ਦੇਣ ਵਿੱਚ ਵੰਡੋ, ਅਤੇ ਵਰਤੋਂ ਬੈਚਾਂ ਵਿੱਚ ਕਤਾਰਾਂ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਲਈ।
17. ਇੱਕ ਵੱਡੀ ਟੇਬਲ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਵੇਲੇ ਮੈਂ ਤਾਲਾਬੰਦੀ ਦੀਆਂ ਸਮੱਸਿਆਵਾਂ ਤੋਂ ਕਿਵੇਂ ਬਚ ਸਕਦਾ ਹਾਂ?
18. ਲਾਕ ਕਰਨ ਦੀਆਂ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਰੋਕਣ ਲਈ, ਅੱਪਡੇਟਾਂ ਨੂੰ ਛੋਟੇ ਬੈਚਾਂ ਵਿੱਚ ਵੰਡਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ, ਪੜਾਵਾਂ ਵਿੱਚ ਤਬਦੀਲੀਆਂ ਕਰਨ ਲਈ ਲੈਣ-ਦੇਣ ਦੀ ਵਰਤੋਂ ਕਰੋ, ਅਤੇ ਘੱਟ-ਵਰਤੋਂ ਦੇ ਘੰਟਿਆਂ ਦੌਰਾਨ ਅੱਪਡੇਟ ਚਲਾਉਣ ਬਾਰੇ ਵਿਚਾਰ ਕਰੋ।
19. ਕੀ ਮੈਂ SQL ਸਰਵਰ ਵਿੱਚ ਵੱਡੀਆਂ ਅੱਪਡੇਟ ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਤਹਿ ਕਰ ਸਕਦਾ ਹਾਂ?
20. ਹਾਂ, SQL ਸਰਵਰ ਏਜੰਟ ਨੂੰ ਸਿਸਟਮ ਪ੍ਰਦਰਸ਼ਨ 'ਤੇ ਪ੍ਰਭਾਵ ਨੂੰ ਘੱਟ ਕਰਨ ਲਈ ਆਫ-ਪੀਕ ਘੰਟਿਆਂ ਦੌਰਾਨ ਵੱਡੀਆਂ ਅੱਪਡੇਟ ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਤਹਿ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ। SQL ਸਰਵਰ ਏਜੰਟ ਵਿੱਚ ਇੱਕ ਨੌਕਰੀ ਬਣਾਓ ਅਤੇ ਲੋੜੀਦਾ ਸਮਾਂ ਨਿਰਧਾਰਤ ਕਰੋ।

ਵੱਡੀਆਂ ਟੇਬਲਾਂ ਨੂੰ ਸੋਧਣ ਲਈ SQL ਸਰਵਰ ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ, ਤੁਹਾਡੇ ਕਾਰਜਾਂ ਨੂੰ ਤੋੜਨਾ ਪ੍ਰਦਰਸ਼ਨ ਨੂੰ ਬਿਹਤਰ ਬਣਾਉਣ ਦੀ ਕੁੰਜੀ ਹੈ। ਲੱਖਾਂ ਕਤਾਰਾਂ ਵਾਲੀ ਇੱਕ ਸਾਰਣੀ ਵਿੱਚ ਇੱਕ ਕਾਲਮ ਜੋੜਨਾ ਅਤੇ ਖਾਸ ਸਥਿਤੀਆਂ ਦੇ ਅਧਾਰ ਤੇ ਡੇਟਾ ਨੂੰ ਅਪਡੇਟ ਕਰਨਾ ਇੱਕ ਚੁਣੌਤੀ ਹੋ ਸਕਦੀ ਹੈ। ਇਸ ਲਈ ਕਮਾਂਡਾਂ ਦੇ ਰਣਨੀਤਕ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਦੀ ਲੋੜ ਹੈ ਜਿਵੇਂ ਕਿ ਅਤੇ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ ਸਿਸਟਮ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕੀਤੇ ਬਿਨਾਂ ਤਬਦੀਲੀਆਂ ਲਾਗੂ ਕੀਤੀਆਂ ਗਈਆਂ ਹਨ।

ਇਸ ਤੋਂ ਇਲਾਵਾ, ਸਰਵੋਤਮ ਅਭਿਆਸਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨਾ ਜਿਵੇਂ ਕਿ ਬੈਚਿੰਗ ਅਪਡੇਟਸ, ਇੰਡੈਕਸਿੰਗ ਦੀ ਵਰਤੋਂ ਕਰਨਾ, ਅਤੇ ਆਫ-ਪੀਕ ਘੰਟਿਆਂ ਦੌਰਾਨ ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਚਲਾਉਣਾ ਟੇਬਲ ਲਾਕਿੰਗ ਅਤੇ ਪ੍ਰਦਰਸ਼ਨ ਵਿੱਚ ਗਿਰਾਵਟ ਵਰਗੀਆਂ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਰੋਕਣ ਵਿੱਚ ਮਦਦ ਕਰ ਸਕਦਾ ਹੈ। ਵਰਕਲੋਡ ਨੂੰ ਵੰਡ ਕੇ ਅਤੇ ਸਵਾਲਾਂ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾ ਕੇ, ਤੁਸੀਂ ਡਾਊਨਟਾਈਮ ਜਾਂ "ਅਵੈਧ ਕਾਲਮ ਨਾਮ" ਵਰਗੀਆਂ ਤਰੁੱਟੀਆਂ ਪੈਦਾ ਕੀਤੇ ਬਿਨਾਂ ਸੁਰੱਖਿਅਤ ਢੰਗ ਨਾਲ ਵੱਡੇ ਪੱਧਰ 'ਤੇ ਬਦਲਾਅ ਕਰ ਸਕਦੇ ਹੋ। 💻