SQL सर्वर (T-SQL) में एक विभाजित तालिका बनाएँ

SQL सर्वर विभाजित तालिकाओं और अनुक्रमणिकाओं का समर्थन करता है। जब एक विभाजित तालिका या अनुक्रमणिका को विभाजित किया जाता है, तो इसका डेटा इकाइयों में विभाजित किया जाता है जिसे एक से अधिक फ़ाइल समूह में फैलाया जा सकता है।

इसलिए, SQL सर्वर में एक विभाजित तालिका बनाने के लिए, आपको पहले फ़ाइल समूह बनाना होगा जो प्रत्येक विभाजन को धारण करेगा। आपको एक पार्टीशन फंक्शन और एक पार्टिशन स्कीम भी बनानी होगी।

तो यह इस प्रकार है:

फ़ाइल समूह बनाएं
एक विभाजन फ़ंक्शन बनाएं
विभाजन योजना बनाएं
विभाजित तालिका बनाएं

नीचे चार विभाजनों वाली तालिका बनाने के लिए इन चरणों का उपयोग करने का एक उदाहरण दिया गया है।

फ़ाइल समूह बनाएं

सबसे पहले, हम डेटाबेस में चार फ़ाइल समूह जोड़ते हैं जिन्हें परीक्षण . कहा जाता है , और फिर उन फ़ाइल समूहों में से प्रत्येक के लिए भौतिक फ़ाइल निर्दिष्ट करें।

ALTER DATABASE Test
ADD FILEGROUP MoviesFg1;
GO  
ALTER DATABASE Test  
ADD FILEGROUP MoviesFg2;  
GO  
ALTER DATABASE Test  
ADD FILEGROUP MoviesFg3;  
GO  
ALTER DATABASE Test  
ADD FILEGROUP MoviesFg4;   

ALTER DATABASE Test   
ADD FILE   
(  
    NAME = MoviesFg1dat,  
    FILENAME = '/var/opt/mssql/data/MoviesFg1dat.ndf',  
    SIZE = 5MB,  
    MAXSIZE = 100MB,  
    FILEGROWTH = 5MB  
)  
TO FILEGROUP MoviesFg1;  
ALTER DATABASE Test   
ADD FILE   
(  
    NAME = MoviesFg2dat,  
    FILENAME = '/var/opt/mssql/data/MoviesFg2dat.ndf',  
    SIZE = 5MB,  
    MAXSIZE = 100MB,  
    FILEGROWTH = 5MB  
)  
TO FILEGROUP MoviesFg2;  
GO  
ALTER DATABASE Test   
ADD FILE   
(  
    NAME = MoviesFg3dat,  
    FILENAME = '/var/opt/mssql/data/MoviesFg3dat.ndf',  
    SIZE = 5MB,  
    MAXSIZE = 100MB,  
    FILEGROWTH = 5MB  
)  
TO FILEGROUP MoviesFg3;  
GO  
ALTER DATABASE Test   
ADD FILE   
(  
    NAME = MoviesFg4dat,  
    FILENAME = '/var/opt/mssql/data/MoviesFg4dat.ndf',  
    SIZE = 5MB,  
    MAXSIZE = 100MB,  
    FILEGROWTH = 5MB  
)  
TO FILEGROUP MoviesFg4;  
GO

आपको अपनी आवश्यकताओं के आधार पर इस कोड को बदलना होगा। आपको अपने परिवेश के अनुरूप फ़ाइल पथ बदलने की भी आवश्यकता होगी। उदाहरण के लिए, यदि आप Windows पर हैं, तो आपका पथ D:\mssql\data\MoviesFg4dat.ndf जैसा दिखाई दे सकता है .

इसके अलावा, यदि आपको अधिक विभाजन की आवश्यकता है तो यहां अधिक फ़ाइल समूह जोड़ें। इसके विपरीत, यदि आपको कम विभाजन की आवश्यकता है, तो यहां कम फ़ाइल समूह निर्दिष्ट करें।

विभाजन फ़ंक्शन बनाएं

इसके बाद हम MoviesPartitionFunction . नामक एक पार्टीशन फ़ंक्शन बनाते हैं जो तालिका को चार विभाजनों में विभाजित करेगा।

CREATE PARTITION FUNCTION MoviesPartitionFunction (int)  
    AS RANGE LEFT FOR VALUES (1, 100, 1000);
GO

इंट part विभाजन के लिए प्रयुक्त कॉलम के डेटा प्रकार को निर्दिष्ट करता है।

पाठ . को छोड़कर, सभी डेटा प्रकार विभाजन कॉलम के रूप में उपयोग के लिए मान्य हैं , ntext , छवि , एक्सएमएल , टाइमस्टैम्प , वर्कर(अधिकतम) , nvarchar(अधिकतम) , varbinary(अधिकतम) , उपनाम डेटा प्रकार, या CLR उपयोगकर्ता-परिभाषित डेटा प्रकार।

यहां, मैं तीन सीमा मानों का उपयोग करता हूं (1, 100 , और 1000 ) चार विभाजन निर्दिष्ट करने के लिए। ये सीमा मान विभाजन फ़ंक्शन के नाम के बाद कोष्ठक में निर्दिष्ट डेटा प्रकार से मेल खाना चाहिए या परोक्ष रूप से परिवर्तनीय होना चाहिए।

इन सीमा मूल्यों को देखते हुए, और इस तथ्य को देखते हुए कि मैंने एक RANGE LEFT specified निर्दिष्ट किया है विभाजन, चार विभाजन निम्न तालिका में निर्दिष्ट मानों को धारण करेंगे।

विभाजन	मान
1	<= `1`
2	> `1` और <= `100`
3	> `100` और <=`1000`
4	> `1000`

अगर मैंने एक RANGE RIGHT निर्दिष्ट किया होता विभाजन, ब्रेकडाउन थोड़ा अलग होगा, जैसा कि निम्न तालिका में बताया गया है।

विभाजन	मान
1	< `1`
2	>= `1` और < `100`
3	>= `100` और < `1000`
4	>= `1000`

यदि विभाजन स्तंभ अन्य डेटा प्रकारों, जैसे दिनांक/समय मानों का उपयोग करता है, तो यही अवधारणा लागू होती है।

विभाजन योजना बनाएं

आगे हमें एक विभाजन योजना बनानी होगी।

एक विभाजन योजना एक विभाजित तालिका या अनुक्रमणिका के विभाजन को नए फ़ाइल समूहों में मैप करती है।

हमारे मामले में, कोड इस तरह दिखेगा:

CREATE PARTITION SCHEME MoviesPartitionScheme  
    AS PARTITION MoviesPartitionFunction  
    TO (MoviesFg1, MoviesFg2, MoviesFg3, MoviesFg4);  
GO

ध्यान दें कि हम उस विभाजन फ़ंक्शन का संदर्भ देते हैं जिसे हमने पिछले चरण में बनाया था। हम पहले चरण में बनाए गए फ़ाइल समूह का भी संदर्भ देते हैं।

विभाजित तालिका बनाएं

अंत में हम विभाजित तालिका बना सकते हैं।

CREATE TABLE Movies (
    MovieId int IDENTITY PRIMARY KEY, 
    MovieName varchar(60)
    )  
    ON MoviesPartitionScheme (MovieId);  
GO

इसमें और अविभाजित तालिका बनाने के बीच एकमात्र अंतर यह है कि विभाजित तालिका बनाते समय, हम ON का उपयोग करते हैं उपयोग करने के लिए एक विभाजन योजना निर्दिष्ट करने के लिए तर्क। हमारे मामले में, हम पिछले चरण में बनाई गई विभाजन योजना को निर्दिष्ट करते हैं, और MovieId निर्दिष्ट करते हैं विभाजन स्तंभ के रूप में स्तंभ।

आप देखेंगे कि MovieId कॉलम का डेटा प्रकार int . है , जो उस सीमा मान से मेल खाता है जिसे हमने विभाजन फ़ंक्शन बनाते समय निर्दिष्ट किया था।

ध्यान दें कि यदि आप किसी पार्टीशन फ़ंक्शन में परिकलित कॉलम का उपयोग करते हैं, तो इसे स्पष्ट रूप से PERSISTED के रूप में चिह्नित किया जाना चाहिए ।

विभाजन फ़ंक्शन की जांच करें

आप sys.partition_functions . का उपयोग कर सकते हैं सभी विभाजन कार्यों को वापस करने के लिए देखें।

SELECT * FROM sys.partition_functions;

परिणाम (ऊर्ध्वाधर आउटपुट का उपयोग करके):

name                    | MoviesPartitionFunction
function_id             | 65536
type                    | R 
type_desc               | RANGE
fanout                  | 4
boundary_value_on_right | 0
is_system               | 0
create_date             | 2020-10-10 05:37:41.330
modify_date             | 2020-10-10 05:37:41.330

विभाजन योजना की जांच करें

आप sys.partition_schemes . का उपयोग कर सकते हैं विभाजन योजना की जाँच करने के लिए।

SELECT * FROM sys.partition_schemes;

परिणाम (ऊर्ध्वाधर आउटपुट का उपयोग करके):

name          | MoviesPartitionScheme
data_space_id | 65601
type          | PS
type_desc     | PARTITION_SCHEME
is_default    | 0
is_system     | 0
function_id   | 65536

वैकल्पिक रूप से, आप अन्य विवरण, जैसे स्कीमा, तालिका, अनुक्रमणिका, आदि को वापस करने के लिए निम्न क्वेरी का उपयोग कर सकते हैं।

SELECT 
    object_schema_name(i.object_id) AS [Schema],
    object_name(i.object_id) AS [Object],
    i.name AS [Index],
    s.name AS [Partition Scheme]
    FROM sys.indexes i
    INNER JOIN sys.partition_schemes s ON i.data_space_id = s.data_space_id;

परिणाम (ऊर्ध्वाधर आउटपुट का उपयोग करके):

Schema           | dbo
Object           | Movies
Index            | PK__Movies__4BD2941A0ED85ACA
Partition Scheme | MoviesPartitionScheme

विभाजित तालिका जांचें

आप sys.dm_db_partition_stats चला सकते हैं वर्तमान डेटाबेस में प्रत्येक विभाजन के लिए पृष्ठ और पंक्ति-गणना जानकारी वापस करने के लिए देखें।

लेकिन तालिका में कोई भी डेटा डालने से पहले इसे चलाने से अधिकांश आंकड़े शून्य हो जाएंगे।

इसलिए मैं पहले डेटा डालने जा रहा हूं।

INSERT INTO Movies
SELECT name FROM OtherDb.dbo.Movies;

परिणाम:

(4079 rows affected)

हम देख सकते हैं कि 4,079 पंक्तियों को सम्मिलित किया गया था।

अब आइए sys.dm_db_partition_stats . को क्वेरी करें देखें।

SELECT *
FROM sys.dm_db_partition_stats
WHERE object_id = OBJECT_ID('dbo.Movies');

परिणाम:

+-------------------+-------------+------------+--------------------+--------------------------+--------------------------+------------------------------+-----------------------+---------------------------+--------------------------------+------------------------------------+-------------------+-----------------------+-------------+
| partition_id      | object_id   | index_id   | partition_number   | in_row_data_page_count   | in_row_used_page_count   | in_row_reserved_page_count   | lob_used_page_count   | lob_reserved_page_count   | row_overflow_used_page_count   | row_overflow_reserved_page_count   | used_page_count   | reserved_page_count   | row_count   |
|-------------------+-------------+------------+--------------------+--------------------------+--------------------------+------------------------------+-----------------------+---------------------------+--------------------------------+------------------------------------+-------------------+-----------------------+-------------|
| 72057594048413696 | 2030630277  | 1          | 1                  | 1                        | 2                        | 9                            | 0                     | 0                         | 0                              | 0                                  | 2                 | 9                     | 1           |
| 72057594048479232 | 2030630277  | 1          | 2                  | 1                        | 2                        | 9                            | 0                     | 0                         | 0                              | 0                                  | 2                 | 9                     | 99          |
| 72057594048544768 | 2030630277  | 1          | 3                  | 3                        | 5                        | 25                           | 0                     | 0                         | 0                              | 0                                  | 5                 | 25                    | 900         |
| 72057594048610304 | 2030630277  | 1          | 4                  | 10                       | 12                       | 33                           | 0                     | 0                         | 0                              | 0                                  | 12                | 33                    | 3079        |
+-------------------+-------------+------------+--------------------+--------------------------+--------------------------+------------------------------+-----------------------+---------------------------+--------------------------------+------------------------------------+-------------------+-----------------------+-------------+

यह दृश्य बहुत सारे स्तंभ लौटाता है, तो आइए स्तंभों को केवल एक जोड़े तक सीमित कर दें।

SELECT 
    partition_number,
    row_count
FROM sys.dm_db_partition_stats
WHERE object_id = OBJECT_ID('dbo.Movies');

परिणाम:

+--------------------+-------------+
| partition_number   | row_count   |
|--------------------+-------------|
| 1                  | 1           |
| 2                  | 99          |
| 3                  | 900         |
| 4                  | 3079        |
+--------------------+-------------+

हम देख सकते हैं कि विभाजनों में पंक्तियों को कैसे आवंटित किया जाता है। वे ठीक वैसे ही आवंटित किए गए हैं जैसे हमने विभाजन फ़ंक्शन में निर्दिष्ट किए हैं। पंक्तियाँ कुल 4,079 हैं, जो कि हमने कितनी पंक्तियाँ डाली हैं।

हालांकि, यह ध्यान देने योग्य है कि Microsoft दस्तावेज़ वास्तव में बताता है कि यह कॉलम केवल एक अनुमानित है प्रत्येक विभाजन में पंक्तियों की संख्या।

सर्वोत्तम अभ्यास

Microsoft अनुशंसा करता है कि हम विभाजन श्रेणी के दोनों सिरों पर हमेशा खाली विभाजन रखें।

ऐसा उस स्थिति में होता है जब आपको भविष्य में विभाजनों को विभाजित या मर्ज करने की आवश्यकता होती है।

इस अनुशंसा का कारण यह गारंटी देना है कि विभाजन विभाजन और विभाजन विलय में कोई अप्रत्याशित डेटा गति नहीं है।

इसलिए, मेरे उदाहरण में डेटा को देखते हुए, मैं कुछ इस तरह दिखने के लिए विभाजन फ़ंक्शन को बदल सकता हूं:

CREATE PARTITION FUNCTION MoviesPartitionFunction (int)  
    AS RANGE LEFT FOR VALUES (-1, 100, 10000);
GO

या अगर मैं 10,000 से अधिक पंक्तियों का अनुमान लगाता हूं, तो मैं एक बड़ी संख्या का उपयोग कर सकता हूं (या अधिक विभाजन बना सकता हूं)।

अगर मैं अपनी विभाजित तालिका बनाने के लिए सभी चरणों को फिर से बनाना चाहता हूं, तो मेरे विभाजन आँकड़े इस तरह दिखाई देंगे:

SELECT 
    partition_number,
    row_count
FROM sys.dm_db_partition_stats
WHERE object_id = OBJECT_ID('dbo.Movies');

परिणाम:

+--------------------+-------------+
| partition_number   | row_count   |
|--------------------+-------------|
| 1                  | 0           |
| 2                  | 100         |
| 3                  | 3979        |
| 4                  | 0           |
+--------------------+-------------+

अब मेरा डेटा मध्य दो विभाजनों में केंद्रित है, और दोनों सिरों पर विभाजन खाली हैं।