SQL సర్వర్‌లో కాలమ్ మరియు అప్‌డేట్ అడ్డు వరుసలను ఎలా సమర్థవంతంగా జోడించాలి

SQL సర్వర్‌లో మాస్టరింగ్ టేబుల్ సవరణలు: దశల వారీ గైడ్

కొన్నిసార్లు, పెద్ద డేటాసెట్‌లతో పని చేయడం ఒకేసారి వంద పనులను మోసగించడానికి ప్రయత్నిస్తున్నట్లు అనిపించవచ్చు. ఇటీవల, నేను మిలియన్‌కు పైగా వరుసలను కలిగి ఉన్న పట్టికకు నిలువు వరుసను జోడించాల్సిన పరిస్థితిని ఎదుర్కొన్నాను. ఇది ఉపరితలంపై ఒక సాధారణ పనిలా కనిపించినప్పటికీ, చాలా మంది SQL సర్వర్ వినియోగదారులు ఎదుర్కొంటున్న రోడ్‌బ్లాక్‌లో నేను త్వరగా పరిగెత్తాను: భయంకరమైన "చెల్లని కాలమ్ పేరు" లోపం. 🧐

నా ALTER TABLE మరియు UPDATE కమాండ్‌లను కలిసి అమలు చేయడానికి అనేక ప్రయత్నాలను అమలు చేసిన తర్వాత, సమస్య లాజిక్‌తో కాదని నా ప్రశ్నల క్రమంలో ఉందని నేను గ్రహించాను. 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 సర్వర్ ఏజెంట్‌ను ఉపయోగించడం సిస్టమ్ పనితీరుపై కనీస ప్రభావాన్ని నిర్ధారిస్తుంది. ఈ ఆప్టిమైజేషన్‌లతో, సిస్టమ్ సమగ్రతను కొనసాగిస్తూ మీరు పెద్ద పట్టికలపై సంక్లిష్ట మార్పులను సురక్షితంగా అమలు చేయవచ్చు. 🖥️