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

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

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

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