MS SQL సర్వర్: స్టెరాయిడ్స్‌పై బ్యాకప్

ఆగండి! ఆగండి! నిజమే, ఇది SQL సర్వర్ బ్యాకప్‌ల రకాల గురించి మరొక కథనం కాదు. రికవరీ మోడళ్ల మధ్య వ్యత్యాసాల గురించి మరియు కట్టడాలు పెరిగిన లాగ్‌తో ఎలా వ్యవహరించాలో కూడా నేను మాట్లాడను.

బహుశా (బహుశా), ఈ పోస్ట్ చదివిన తర్వాత, ప్రామాణిక మార్గాలను ఉపయోగించి మీ నుండి తీసివేయబడిన బ్యాకప్ రేపు రాత్రి, అలాగే, 1.5 రెట్లు వేగంగా తీసివేయబడుతుందని మీరు నిర్ధారించుకోగలరు. మరియు మీరు కొంచెం ఎక్కువ బ్యాకప్ డేటాబేస్ పారామితులను ఉపయోగించడం వల్ల మాత్రమే.

పోస్ట్‌లోని కంటెంట్ మీకు స్పష్టంగా కనిపిస్తే, నన్ను క్షమించండి. "habr sql సర్వర్ బ్యాకప్" అనే పదబంధం కోసం Googleకి లభించిన ప్రతిదాన్ని నేను చదివాను మరియు పారామితులను ఉపయోగించి బ్యాకప్ సమయాన్ని ఎలాగైనా ప్రభావితం చేయవచ్చనే వాస్తవం గురించి ఒక్క కథనంలో కూడా నేను ప్రస్తావించలేదు.

నేను వెంటనే మీ దృష్టిని అలెగ్జాండర్ గ్లాడ్చెంకో యొక్క వ్యాఖ్యకు ఆకర్షిస్తాను (@mssqlhelp):

ఉత్పత్తిలో BUFFERCOUNT, BLOCKSIZE, MAXTRANSFERSIZE పారామితులను ఎప్పుడూ మార్చవద్దు. అవి అటువంటి వ్యాసాలు రాయడానికి మాత్రమే తయారు చేయబడ్డాయి. ఆచరణలో, మీరు ఏ సమయంలోనైనా జ్ఞాపకశక్తి సమస్యలను తొలగిస్తారు.

వాస్తవానికి, తెలివిగా మరియు ప్రత్యేకమైన కంటెంట్‌ను పోస్ట్ చేయడం చాలా బాగుంది, కానీ, దురదృష్టవశాత్తు, ఇది అలా కాదు. ఈ అంశానికి అంకితం చేయబడిన ఆంగ్ల-భాష మరియు రష్యన్-భాషా కథనాలు/పోస్ట్‌లు రెండూ ఉన్నాయి (వాటిని సరిగ్గా ఏమని పిలవాలో తెలియక నేను ఎల్లప్పుడూ గందరగోళంగా ఉంటాను). నేను చూసిన వాటిలో కొన్ని ఇక్కడ ఉన్నాయి: సమయం, два, మూడు (sql.ruలో).

కాబట్టి, ప్రారంభించడానికి, నేను కొంచెం తీసివేసిన బ్యాకప్ సింటాక్స్‌ని అటాచ్ చేస్తాను MSDN (మార్గం ద్వారా, నేను బ్యాకప్ డేటాబేస్ గురించి పైన వ్రాసాను, అయితే ఇదంతా లావాదేవీ లాగ్ బ్యాకప్ మరియు అవకలన బ్యాకప్ రెండింటికీ వర్తిస్తుంది, కానీ బహుశా తక్కువ స్పష్టమైన ప్రభావంతో):

BACKUP DATABASE { database_name | @database_name_var }
  TO <backup_device> [ ,...n ]
  <...>
  [ WITH { <...>
           | <general_WITH_options> [ ,...n ] } ]
[;]

<general_WITH_options> [ ,...n ]::=
<...>
--Media Set Options
 <...>
 | BLOCKSIZE = { blocksize | @blocksize_variable }

--Data Transfer Options
   BUFFERCOUNT = { buffercount | @buffercount_variable }
 | MAXTRANSFERSIZE = { maxtransfersize | @maxtransfersize_variable }
<...>

<…> - అక్కడ ఏదో ఉందని అర్థం, కానీ ఇప్పుడు అది అంశానికి సంబంధించినది కాదు కాబట్టి నేను దాన్ని తీసివేసాను.

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

BACKUP DATABASE smth
TO DISK = 'D:Backupsmth.bak'
WITH STATS = 10, CHECKSUM, COMPRESSION, COPY_ONLY;
--ладно, CHECKSUM я написал только чтобы казаться умнее

మరియు, సాధారణంగా, బ్యాకప్‌ల గురించిన కథనాలలో సాధారణంగా పేర్కొన్న అన్ని పారామితులలో 75-90% ఇక్కడ జాబితా చేయబడ్డాయి. సరే, INIT, SKIP కూడా ఉంది. మీరు MSDNని సందర్శించారా? ఒకటిన్నర స్క్రీన్‌ల కోసం ఎంపికలు ఉన్నాయని మీరు చూశారా? నేను కూడా చూసాను...

BLOCKSIZE, BUFFERCOUNT మరియు MAXTRANSFERSIZE - కోడ్ యొక్క మొదటి బ్లాక్‌లో మిగిలి ఉన్న మూడు పారామితుల గురించి మేము మరింత మాట్లాడతామని మీరు ఇప్పటికే గ్రహించి ఉండవచ్చు. MSDN నుండి వారి వివరణలు ఇక్కడ ఉన్నాయి:

బ్లాక్‌సైజ్ = { బ్లాక్‌సైజ్ | @ blocksize_variable } - బైట్‌లలో భౌతిక బ్లాక్ పరిమాణాన్ని సూచిస్తుంది. 512, 1024, 2048, 4096, 8192, 16, 384 మరియు 32 బైట్‌లు (768 KB) మద్దతు ఉన్న పరిమాణాలు. టేప్ పరికరాల కోసం డిఫాల్ట్ విలువ 65 మరియు ఇతర పరికరాల కోసం 536. సాధారణంగా ఈ పరామితి అవసరం లేదు ఎందుకంటే బ్యాకప్ స్టేట్‌మెంట్ స్వయంచాలకంగా పరికరం కోసం తగిన బ్లాక్ పరిమాణాన్ని ఎంచుకుంటుంది. బ్లాక్ పరిమాణాన్ని సెట్ చేయడం ఆటోమేటిక్ బ్లాక్ సైజు ఎంపికను స్పష్టంగా భర్తీ చేస్తుంది.

బఫర్‌కౌంట్ = { బఫర్‌కౌంట్ | @ బఫర్‌కౌంట్_వేరియబుల్ } - బ్యాకప్ ఆపరేషన్ కోసం ఉపయోగించబడే మొత్తం I/O బఫర్‌ల సంఖ్యను నిర్వచిస్తుంది. మీరు ఏదైనా ధనాత్మక పూర్ణాంకం విలువను పేర్కొనవచ్చు, కానీ Sqlservr.exe ప్రాసెస్‌లో అధిక వర్చువల్ అడ్రస్ స్పేస్ కారణంగా పెద్ద సంఖ్యలో బఫర్‌లు మెమరీలో లోపం ఏర్పడవచ్చు.

బఫర్‌లు ఉపయోగించే మొత్తం స్థలం క్రింది సూత్రం ద్వారా నిర్ణయించబడుతుంది: BUFFERCOUNT * MAXTRANSFERSIZE.

MAXTRANSFERSIZE = { maxtransfersize | @ maxtransfersize_variable } SQL సర్వర్ మరియు బ్యాకప్ సెట్ మీడియా మధ్య మార్పిడి చేయడానికి బైట్‌లలో అతిపెద్ద డేటా ప్యాకెట్ పరిమాణాన్ని నిర్దేశిస్తుంది. 65 బైట్‌ల (536 MB) వరకు 64 బైట్‌ల (4 KB) గుణిజాలకు మద్దతు ఉంది.

నేను ప్రమాణం చేస్తున్నాను - నేను ఇంతకు ముందు చదివాను, కానీ అవి ఉత్పాదకతపై ఎంత ప్రభావం చూపగలవని నాకు ఎప్పుడూ అనిపించలేదు. అంతేకాక, స్పష్టంగా, నేను ఒక రకమైన "బయటికి రావడం" చేయవలసి ఉంది మరియు ఇప్పుడు కూడా వారు సరిగ్గా ఏమి చేస్తున్నారో నాకు పూర్తిగా అర్థం కాలేదు. నేను బఫర్ చేయబడిన I/O మరియు హార్డ్ డ్రైవ్‌తో పని చేయడం గురించి మరింత చదవవలసి ఉంటుంది. ఏదో ఒక రోజు నేను దీన్ని చేస్తాను, కానీ ప్రస్తుతానికి నేను బ్యాకప్ తీసుకునే వేగాన్ని ఈ విలువలు ఎలా ప్రభావితం చేస్తాయో తనిఖీ చేసే స్క్రిప్ట్‌ను వ్రాయగలను.

నేను 10 GB పరిమాణంలో ఒక చిన్న డేటాబేస్‌ని తయారు చేసాను, దానిని SSDలో ఉంచాను మరియు HDDలో బ్యాకప్‌ల కోసం డైరెక్టరీని ఉంచాను.

ఫలితాలను నిల్వ చేయడానికి నేను తాత్కాలిక పట్టికను సృష్టిస్తాను (నాకు ఇది తాత్కాలికంగా లేదు, కాబట్టి నేను ఫలితాలను మరింత వివరంగా తీయగలను, కానీ మీరే నిర్ణయించుకోండి):

DROP TABLE IF EXISTS ##bt_results; 

CREATE TABLE ##bt_results (
    id              int IDENTITY (1, 1) PRIMARY KEY,
    start_date      datetime NOT NULL,
    finish_date     datetime NOT NULL,
    backup_size     bigint NOT NULL,
    compressed_size bigint,
    block_size      int,
    buffer_count    int,
    transfer_size   int
);

స్క్రిప్ట్ యొక్క సూత్రం సులభం - సమూహ లూప్‌లు, వీటిలో ప్రతి ఒక్కటి ఒక పరామితి యొక్క విలువను మారుస్తుంది, ఈ పారామితులను BACKUP కమాండ్‌లోకి చొప్పించండి, msdb.dbo.backupset నుండి చరిత్రతో చివరి రికార్డ్‌ను సేవ్ చేయండి, బ్యాకప్ ఫైల్ మరియు తదుపరి పునరావృతాన్ని తొలగించండి . బ్యాకప్ ఎగ్జిక్యూషన్ డేటా బ్యాకప్‌సెట్ నుండి తీసుకోబడినందున, ఖచ్చితత్వం కొంతవరకు పోతుంది (సెకన్ల భిన్నాలు లేవు), కానీ మేము దీన్ని మనుగడ సాగిస్తాము.

ముందుగా మీరు బ్యాకప్‌లను తొలగించడానికి xp_cmdshellని ప్రారంభించాలి (అప్పుడు మీకు అవసరం లేకుంటే దాన్ని నిలిపివేయడం మర్చిపోవద్దు):

EXEC sp_configure 'show advanced options', 1;  
EXEC sp_configure 'xp_cmdshell', 1;
RECONFIGURE;
EXEC sp_configure 'show advanced options', 0;  
GO

బాగా, నిజానికి:

DECLARE @tmplt AS nvarchar(max) = N'
BACKUP DATABASE [bt]
TO DISK = ''D:SQLServerbackupbt.bak''
WITH 
    COMPRESSION,
    BLOCKSIZE = {bs},
    BUFFERCOUNT = {bc},
    MAXTRANSFERSIZE = {ts}';

DECLARE @sql AS nvarchar(max);

/* BLOCKSIZE values */
DECLARE @bs     int = 4096, 
        @max_bs int = 65536;

/* BUFFERCOUNT values */
DECLARE @bc     int = 7,
        @min_bc int = 7,
        @max_bc int = 800;

/* MAXTRANSFERSIZE values */
DECLARE @ts     int = 524288,   --512KB, default = 1024KB
        @min_ts int = 524288,
        @max_ts int = 4194304;  --4MB

SELECT TOP 1 
    @bs = COALESCE (block_size, 4096), 
    @bc = COALESCE (buffer_count, 7), 
    @ts = COALESCE (transfer_size, 524288)
FROM ##bt_results
ORDER BY id DESC;

WHILE (@bs <= @max_bs)
BEGIN
    WHILE (@bc <= @max_bc)
    BEGIN       
        WHILE (@ts <= @max_ts)
        BEGIN
            SET @sql = REPLACE (REPLACE (REPLACE(@tmplt, N'{bs}', CAST(@bs AS nvarchar(50))), N'{bc}', CAST (@bc AS nvarchar(50))), N'{ts}', CAST (@ts AS nvarchar(50)));

            EXEC (@sql);

            INSERT INTO ##bt_results (start_date, finish_date, backup_size, compressed_size, block_size, buffer_count, transfer_size)
            SELECT TOP 1 backup_start_date, backup_finish_date, backup_size, compressed_backup_size,  @bs, @bc, @ts 
            FROM msdb.dbo.backupset
            ORDER BY backup_set_id DESC;

            EXEC xp_cmdshell 'del "D:SQLServerbackupbt.bak"', no_output;

            SET @ts += @ts;
        END
        
        SET @bc += @bc;
        SET @ts = @min_ts;

        WAITFOR DELAY '00:00:05';
    END

    SET @bs += @bs;
    SET @bc = @min_bc;
    SET @ts = @min_ts;
END

ఇక్కడ ఏమి జరుగుతుందో మీకు అకస్మాత్తుగా స్పష్టత అవసరమైతే, వ్యాఖ్యలలో లేదా PMలో వ్రాయండి. ప్రస్తుతానికి, నేను బ్యాకప్ డేటాబేస్‌లో ఉంచిన పారామితుల గురించి మాత్రమే మీకు చెప్తాను.

BLOCKSIZE కోసం మేము "మూసివేయబడిన" విలువల జాబితాను కలిగి ఉన్నాము మరియు నేను BLOCKSIZE <4KBతో బ్యాకప్ చేయలేదు. 64KB నుండి 64MB వరకు - 4KB గుణకారం ఉన్న ఏదైనా సంఖ్యను గరిష్టంగా మార్చండి. నా సిస్టమ్‌లో డిఫాల్ట్ 1024KB, నేను 512 - 1024 - 2048 - 4096 తీసుకున్నాను.

BUFFERCOUNTతో ఇది చాలా కష్టమైంది - ఇది ఏదైనా సానుకూల సంఖ్య కావచ్చు, కానీ లింక్ చెబుతుంది బ్యాకప్ డేటాబేస్‌లో ఇది ఎలా లెక్కించబడుతుంది మరియు పెద్ద విలువలు ఎందుకు ప్రమాదకరమైనవి?. నిజానికి బ్యాకప్ ఏ బఫర్‌కౌంట్‌తో తయారు చేయబడిందనే దాని గురించి సమాచారాన్ని ఎలా పొందాలో కూడా ఇది చెబుతుంది - నాకు ఇది 7. దీన్ని తగ్గించడంలో ఎటువంటి ప్రయోజనం లేదు మరియు ఎగువ పరిమితి ప్రయోగాత్మకంగా కనుగొనబడింది - BUFFERCOUNT = 896 మరియు MAXTRANSFERSIZE = 4194304తో బ్యాకప్ పడిపోయింది ఒక లోపం (దాని గురించి పై లింక్‌లో వ్రాయబడింది):

సందేశం 3013, స్థాయి 16, రాష్ట్రం 1, లైన్ 7 బ్యాకప్ డేటాబేస్ అసాధారణంగా ముగుస్తుంది.

Msg 701, లెవెల్ 17, స్టేట్ 123, లైన్ 7 ఈ ప్రశ్నను అమలు చేయడానికి రిసోర్స్ పూల్ 'డిఫాల్ట్'లో తగినంత సిస్టమ్ మెమరీ లేదు.

పోలిక కోసం, నేను మొదట ఎటువంటి పారామీటర్‌లను పేర్కొనకుండా బ్యాకప్‌ను అమలు చేసే ఫలితాలను చూపుతాను:

BACKUP DATABASE [bt]
TO DISK = 'D:SQLServerbackupbt.bak'
WITH COMPRESSION;

బాగా, బ్యాకప్ మరియు బ్యాకప్:

డేటాబేస్ 'bt' కోసం 1070072 పేజీలు ప్రాసెస్ చేయబడ్డాయి, ఫైల్ 1లో 'bt' ఫైల్.

డేటాబేస్ 'bt' కోసం 2 పేజీలు ప్రాసెస్ చేయబడ్డాయి, ఫైల్ 1లో 'bt_log' ఫైల్.

బ్యాకప్ డేటాబేస్ 1070074 పేజీలను 53.171 సెకన్లలో (157.227 MB/సెకను) విజయవంతంగా ప్రాసెస్ చేసింది.

స్క్రిప్ట్ కూడా, పారామితులను పరీక్షించడం, కొన్ని గంటల్లో పని చేస్తుంది, అన్ని కొలతలు ఉన్నాయి గూగుల్ స్ప్రెడ్‌షీట్. మరియు ఇక్కడ మూడు ఉత్తమ ఎగ్జిక్యూషన్ సమయాలతో కూడిన ఫలితాల ఎంపిక ఉంది (నేను చక్కని గ్రాఫ్‌ని రూపొందించడానికి ప్రయత్నించాను, కానీ పోస్ట్‌లో నేను టేబుల్‌తో మరియు వ్యాఖ్యలలో చేయవలసి ఉంటుంది @మిక్స్చర్ ఆయన చాలా కూల్ గ్రాఫిక్స్).

SELECT TOP 7 WITH TIES 
    compressed_size, 
    block_size, 
    buffer_count, 
    transfer_size,
    DATEDIFF(SECOND, start_date, finish_date) AS backup_time_sec
FROM ##bt_results
ORDER BY backup_time_sec ASC;

శ్రద్ధ, నుండి చాలా ముఖ్యమైన గమనిక @మిక్స్చర్ నుండి వ్యాఖ్యానం:

ఈ విలువల పరిధిలోని పారామితులు మరియు బ్యాకప్ వేగం మధ్య సంబంధం యాదృచ్ఛికంగా ఉందని మేము నమ్మకంగా చెప్పగలం, నమూనా లేదు. కానీ అంతర్నిర్మిత పారామితుల నుండి దూరంగా వెళ్లడం స్పష్టంగా ఫలితంపై మంచి ప్రభావాన్ని చూపింది

ఆ. ప్రామాణిక BACKUP పారామితులను నిర్వహించడం ద్వారా మాత్రమే బ్యాకప్ తీసివేత సమయంలో 2 రెట్లు లాభం: 26 సెకన్లు, ప్రారంభంలో 53. అది చెడ్డది కాదు, సరియైనదా? అయితే పునరుద్ధరణతో ఏం జరుగుతుందో చూడాలి. కోలుకోవడానికి ఇప్పుడు 4 రెట్లు ఎక్కువ సమయం తీసుకుంటే?

ముందుగా, డిఫాల్ట్ సెట్టింగ్‌లతో బ్యాకప్‌ని పునరుద్ధరించడానికి ఎంత సమయం పడుతుందో కొలవండి:

RESTORE DATABASE [bt]
FROM DISK = 'D:SQLServerbackupbt.bak'
WITH REPLACE, RECOVERY;

బాగా, మీకు మీరే తెలుసు, మార్గాలు ఉన్నాయి, భర్తీ చేయడం భర్తీ చేయదు, రికవరీ అనేది రికవరీ కాదు. మరియు నేను ఇలా చేస్తాను:

డేటాబేస్ 'bt' కోసం 1070072 పేజీలు ప్రాసెస్ చేయబడ్డాయి, ఫైల్ 1లో 'bt' ఫైల్.

డేటాబేస్ 'bt' కోసం 2 పేజీలు ప్రాసెస్ చేయబడ్డాయి, ఫైల్ 1లో 'bt_log' ఫైల్.

డేటాబేస్ పునరుద్ధరించు 1070074 పేజీలను 40.752 సెకన్లలో (205.141 MB/సెకను) విజయవంతంగా ప్రాసెస్ చేసింది.

ఇప్పుడు నేను మార్చబడిన BLOCKSIZE, BUFFERCOUNT మరియు MAXTRANSFERSIZEతో తీసిన బ్యాకప్‌లను పునరుద్ధరించడానికి ప్రయత్నిస్తాను.

BLOCKSIZE = 16384, BUFFERCOUNT = 224, MAXTRANSFERSIZE = 4194304

డేటాబేస్ పునరుద్ధరించు 1070074 పేజీలను 32.283 సెకన్లలో (258.958 MB/సెకను) విజయవంతంగా ప్రాసెస్ చేసింది.

BLOCKSIZE = 4096, BUFFERCOUNT = 448, MAXTRANSFERSIZE = 4194304

డేటాబేస్ పునరుద్ధరించు 1070074 పేజీలను 32.682 సెకన్లలో (255.796 MB/సెకను) విజయవంతంగా ప్రాసెస్ చేసింది.

BLOCKSIZE = 16384, BUFFERCOUNT = 448, MAXTRANSFERSIZE = 2097152

డేటాబేస్ పునరుద్ధరించు 1070074 పేజీలను 32.091 సెకన్లలో (260.507 MB/సెకను) విజయవంతంగా ప్రాసెస్ చేసింది.

BLOCKSIZE = 4096, BUFFERCOUNT = 56, MAXTRANSFERSIZE = 4194304

డేటాబేస్ పునరుద్ధరించు 1070074 పేజీలను 32.401 సెకన్లలో (258.015 MB/సెకను) విజయవంతంగా ప్రాసెస్ చేసింది.

రికవరీ సమయంలో రిస్టోర్ డేటాబేస్ స్టేట్‌మెంట్ మారదు; ఈ పారామితులు అందులో పేర్కొనబడలేదు; SQL సర్వర్ వాటిని బ్యాకప్ నుండి నిర్ణయిస్తుంది. మరియు రికవరీతో కూడా లాభం ఉండవచ్చు - దాదాపు 20% వేగంగా (నిజం చెప్పాలంటే, నేను కోలుకోవడానికి ఎక్కువ సమయం వెచ్చించలేదు, నేను అనేక "వేగవంతమైన" బ్యాకప్‌ల ద్వారా పరిగెత్తాను మరియు ఎటువంటి క్షీణత లేదని నిర్ధారించుకున్నాను).

ఒకవేళ, ఇవి అందరికీ అనుకూలమైన కొన్ని పారామితులు కాదని నేను స్పష్టం చేస్తాను. మీరు పరీక్షించడం ద్వారా మీ కోసం సరైన పారామితులను మాత్రమే పొందవచ్చు. నేను ఈ ఫలితాలను పొందాను, మీరు వేరే వాటిని పొందుతారు. కానీ మీరు మీ బ్యాకప్‌లను "ట్యూన్" చేయగలరని మీరు చూస్తారు మరియు అవి వాస్తవానికి ఏర్పడతాయి మరియు వేగంగా అమర్చవచ్చు.

మీరు డాక్యుమెంటేషన్‌ను పూర్తిగా చదవాలని కూడా నేను గట్టిగా సిఫార్సు చేస్తున్నాను, ఎందుకంటే మీ సిస్టమ్‌కు నిర్దిష్టమైన సూక్ష్మ నైపుణ్యాలు ఉండవచ్చు.

నేను బ్యాకప్‌ల గురించి రాయడం ప్రారంభించినప్పటి నుండి, నేను వెంటనే మరొక “ఆప్టిమైజేషన్” గురించి వ్రాయాలనుకుంటున్నాను, ఇది “ట్యూనింగ్” పారామితుల కంటే సర్వసాధారణం (నేను అర్థం చేసుకున్నంతవరకు, ఇది కనీసం కొన్ని బ్యాకప్ యుటిలిటీల ద్వారా ఉపయోగించబడుతుంది, బహుశా పారామితులతో కలిపి ఉండవచ్చు. ఇంతకు ముందు వివరించబడింది), కానీ ఇది ఇంకా హబ్రేలో కూడా వివరించబడలేదు.

మేము డాక్యుమెంటేషన్‌లోని రెండవ పంక్తిని చూస్తే, బ్యాకప్ డేటాబేస్ క్రింద, అక్కడ మనకు కనిపిస్తుంది:

TO <backup_device> [ ,...n ]

మీరు అనేక backup_devicesని పేర్కొంటే ఏమి జరుగుతుందని మీరు అనుకుంటున్నారు? వాక్యనిర్మాణం దానిని అనుమతిస్తుంది. మరియు చాలా ఆసక్తికరమైన విషయం జరుగుతుంది - బ్యాకప్ అనేక పరికరాలలో "వ్యాప్తి" అవుతుంది. ఆ. ప్రతి “పరికరం” వ్యక్తిగతంగా పనికిరానిది, ఒకటి పోతుంది, మొత్తం బ్యాకప్‌ను కోల్పోతుంది. కానీ అలాంటి స్మెరింగ్ బ్యాకప్ వేగాన్ని ఎలా ప్రభావితం చేస్తుంది?

ఒకే ఫోల్డర్‌లో పక్కపక్కనే ఉన్న రెండు “పరికరాలు” బ్యాకప్ చేయడానికి ప్రయత్నిద్దాం:

BACKUP DATABASE [bt]
TO 
    DISK = 'D:SQLServerbackupbt1.bak',
    DISK = 'D:SQLServerbackupbt2.bak'   
WITH COMPRESSION;

లోక తండ్రులారా, ఇలా ఎందుకు చేస్తున్నారు?

డేటాబేస్ 'bt' కోసం 1070072 పేజీలు ప్రాసెస్ చేయబడ్డాయి, ఫైల్ 1లో 'bt' ఫైల్.

డేటాబేస్ 'bt' కోసం 2 పేజీలు ప్రాసెస్ చేయబడ్డాయి, ఫైల్ 'bt'ఫైల్ 1లో లాగిన్ అవ్వండి.

బ్యాకప్ డేటాబేస్ 1070074 పేజీలను 40.092 సెకన్లలో (208.519 MB/సెకను) విజయవంతంగా ప్రాసెస్ చేసింది.

బ్యాకప్ కేవలం నీలం నుండి 25% వేగంగా మారిందా? మనం మరికొన్ని పరికరాలను జోడిస్తే?

BACKUP DATABASE [bt]
TO 
    DISK = 'D:SQLServerbackupbt1.bak',
    DISK = 'D:SQLServerbackupbt2.bak',
    DISK = 'D:SQLServerbackupbt3.bak',
    DISK = 'D:SQLServerbackupbt4.bak'
WITH COMPRESSION;

బ్యాకప్ డేటాబేస్ 1070074 పేజీలను 34.234 సెకన్లలో (244.200 MB/సెకను) విజయవంతంగా ప్రాసెస్ చేసింది.

మొత్తంగా, ఒక డిస్క్‌లో ఒకేసారి 35 ఫైల్‌లకు బ్యాకప్ వ్రాయబడినందున మాత్రమే బ్యాకప్ తీసుకునే సమయంలో లాభం దాదాపు 4% ఉంటుంది. నేను పెద్ద సంఖ్యను తనిఖీ చేసాను - నా ల్యాప్‌టాప్‌లో ఎటువంటి లాభం లేదు, ఉత్తమంగా - 4 పరికరాలు. మీ కోసం - నాకు తెలియదు, మీరు తనిఖీ చేయాలి. బాగా, మార్గం ద్వారా, మీరు ఈ పరికరాలను కలిగి ఉంటే - ఇవి నిజంగా విభిన్న డిస్కులు, అభినందనలు, లాభం మరింత ముఖ్యమైనదిగా ఉండాలి.

ఈ ఆనందాన్ని ఎలా పునరుద్ధరించాలో ఇప్పుడు మాట్లాడుదాం. దీన్ని చేయడానికి, మీరు రికవరీ ఆదేశాన్ని మార్చాలి మరియు అన్ని పరికరాలను జాబితా చేయాలి:

RESTORE DATABASE [bt]
FROM 
    DISK = 'D:SQLServerbackupbt1.bak',
    DISK = 'D:SQLServerbackupbt2.bak',
    DISK = 'D:SQLServerbackupbt3.bak',
    DISK = 'D:SQLServerbackupbt4.bak'
WITH REPLACE, RECOVERY;

డేటాబేస్ పునరుద్ధరించు 1070074 పేజీలను 38.027 సెకన్లలో (219.842 MB/సెకను) విజయవంతంగా ప్రాసెస్ చేసింది.

కొంచెం వేగంగా, కానీ ఎక్కడా దగ్గరగా, ముఖ్యమైనది కాదు. సాధారణంగా, బ్యాకప్ వేగంగా తీసివేయబడుతుంది మరియు అదే విధంగా పునరుద్ధరించబడుతుంది - విజయం? నా విషయానికొస్తే, ఇది చాలా విజయవంతమైంది. ఈ ముఖ్యం, కాబట్టి నేను పునరావృతం - మీరు ఉంటే మీరు ఈ ఫైల్‌లలో కనీసం ఒకదానిని పోగొట్టుకుంటే, మీరు మొత్తం బ్యాకప్‌ను కోల్పోతారు.

మీరు ట్రేస్ ఫ్లాగ్‌లు 3213 మరియు 3605 ఉపయోగించి ప్రదర్శించబడే బ్యాకప్ సమాచారం వద్ద లాగ్‌లో చూస్తే, అనేక పరికరాలకు బ్యాకప్ చేస్తున్నప్పుడు, కనీసం BUFFERCOUNT సంఖ్య పెరుగుతుందని మీరు గమనించవచ్చు. బహుశా, మీరు BUFFERCOUNT, BLOCKSIZE, MAXTRANSFERSIZE కోసం మరింత అనుకూలమైన పారామితులను ఎంచుకోవడానికి ప్రయత్నించవచ్చు, కానీ నేను వెంటనే విజయవంతం కాలేదు మరియు అలాంటి పరీక్షను మళ్లీ నిర్వహించడానికి నేను చాలా సోమరిగా ఉన్నాను, కానీ వేరే సంఖ్యలో ఫైల్‌ల కోసం. మరియు ఇది చక్రాల గురించి అవమానకరం. మీరు ఇంట్లో అలాంటి పరీక్షను నిర్వహించాలనుకుంటే, స్క్రిప్ట్‌ను రీమేక్ చేయడం కష్టం కాదు.

చివరగా, ధర గురించి మాట్లాడుకుందాం. వినియోగదారుల పనికి సమాంతరంగా బ్యాకప్ తీసివేయబడితే, మీరు పరీక్షకు చాలా బాధ్యతాయుతమైన విధానాన్ని తీసుకోవాలి, ఎందుకంటే బ్యాకప్ వేగంగా తీసివేయబడితే, డిస్క్‌లు మరింత ఒత్తిడికి గురవుతాయి, ప్రాసెసర్‌పై లోడ్ పెరుగుతుంది (మీరు ఇంకా కుదించవలసి ఉంటుంది అది ఎగిరిపోతుంది), మరియు తదనుగుణంగా, సిస్టమ్ యొక్క మొత్తం ప్రతిస్పందన తగ్గుతుంది.

తమాషా చేస్తున్నాను, కానీ నేను ఎలాంటి రివిలేషన్‌లు చేయలేదని నాకు బాగా అర్థమైంది. పైన వ్రాసినది కేవలం మీరు బ్యాకప్‌లను తీసుకోవడానికి సరైన పారామితులను ఎలా ఎంచుకోవచ్చు అనేదానికి ఒక ప్రదర్శన.

మీరు చేసే ప్రతి పని మీ స్వంత అపాయం మరియు ప్రమాదంలో జరుగుతుందని గుర్తుంచుకోండి. మీ బ్యాకప్‌లను తనిఖీ చేయండి మరియు DBCC CHECKDB గురించి మర్చిపోవద్దు.

మూలం: www.habr.com