🚶🏻 〽️ 🚯 एसक्यूएल इंडेक्स मैनेजर - इंडेक्स को डीफ़्रैग्मेन्ट करने और बनाए रखने के लिए एक मुफ्त टूल ♑️ 💭 🤞🏼

कई वर्षों तक SQL सर्वर DBA के रूप में कार्य करना और सर्वर प्रशासन करना, फिर प्रदर्शन अनुकूलन। सामान्य तौर पर, मैं अपने खाली समय में यूनिवर्स और अपने सहयोगियों के लिए कुछ उपयोगी करना चाहता था। इसलिए अंत में हमें SQL Server और Azure के लिए एक छोटा सा ओपन सोर्स इंडेक्स मेंटेनेंस टूल मिला।

एसक्यूएल इंडेक्स मैनेजर

विचार

कभी-कभी, अपनी प्राथमिकताओं पर काम करते समय, लोग उंगली से टाइप करने वाली बैटरी से मिलते-जुलते हो सकते हैं - केवल एक फ्लैश के लिए पर्याप्त प्रेरणा शुल्क है, और फिर वह है। और हाल तक, मैं जीवन के इस अवलोकन के लिए कोई अपवाद नहीं था। अक्सर मुझे अपने स्वयं के कुछ बनाने के लिए विचारों द्वारा दौरा किया गया था, लेकिन प्राथमिकताएं बदल गईं और कुछ भी अंत में नहीं लाया गया।

मेरी प्रेरणा और पेशेवर विकास पर एक काफी मजबूत प्रभाव खार्कोव कंपनी डेवर्ट में काम द्वारा प्रदान किया गया था, जो कि SQL सर्वर, MySQL और Oracle डेटाबेस के विकास और प्रशासन के लिए सॉफ्टवेयर के निर्माण में लगा हुआ था।

उनके पास आने से पहले, मुझे अपना स्वयं का उत्पाद बनाने की बारीकियों का बहुत कम पता था, लेकिन पहले से ही इस प्रक्रिया में मुझे SQL सर्वर की आंतरिक संरचना के बारे में बहुत ज्ञान प्राप्त हुआ। एक वर्ष से अधिक समय से उनके उत्पाद लाइनों में मेटाडेटा अनुरोधों का अनुकूलन करने के बाद, मैं धीरे-धीरे यह समझने लगा कि किसी अन्य की तुलना में बाजार में कौन सी कार्यक्षमता अधिक है।

एक निश्चित स्तर पर, एक नया आला उत्पाद बनाने के लिए विचार उत्पन्न हुआ, लेकिन परिस्थितियों के कारण यह विचार नहीं हुआ। उस समय, नए प्रोजेक्ट के लिए, कंपनी के भीतर मुख्य व्यवसाय के पक्षपात के बिना पर्याप्त पर्याप्त मुक्त संसाधन नहीं थे।

पहले से ही जब उन्होंने एक नई जगह पर काम किया और अपने दम पर प्रोजेक्ट करने की कोशिश की, तो उन्हें लगातार कुछ समझौते करने पड़े। सुविधाओं से भरे एक बड़े उत्पाद को बनाने का प्रारंभिक विचार जल्दी से शून्य हो गया और धीरे-धीरे एक अलग दिशा में बदल गया - योजनाबद्ध कार्यक्षमता को अलग-अलग मिनी-टूल में तोड़ने और उन्हें एक-दूसरे से स्वतंत्र रूप से लागू करने के लिए।

नतीजतन, SQL सूचकांक प्रबंधक का जन्म हुआ - SQL सर्वर और Azure के लिए एक मुफ्त सूचकांक रखरखाव उपकरण। मुख्य विचार रेडगेट और डेवर्ट से एक आधार वाणिज्यिक विकल्प के रूप में लेना और उनकी कार्यक्षमता में सुधार करने का प्रयास करना था। दोनों शुरुआती और अनुभवी उपयोगकर्ताओं के लिए, आसानी से अनुक्रमित विश्लेषण और बनाए रखने की क्षमता।

कार्यान्वयन

शब्दों में, सब कुछ हमेशा सरल लगता है ... उन्होंने vidosikov को प्रेरित करने वाले एक जोड़े पर एक नज़र डाली, एक रैक में खड़ा था और एक शांत उत्पाद बनाने के लिए शुरू किया। लेकिन व्यवहार में, सब कुछ इतना रसीला नहीं है, क्योंकि sysinos_db_index_physical_stats सिस्टम टेबल फ़ंक्शन के साथ काम करते समय कई नुकसान होते हैं और, संयोजन में, एकमात्र स्थान जहां से आप सूचकांक विखंडन के बारे में प्रासंगिक जानकारी प्राप्त कर सकते हैं।

विकास के पहले दिनों से, मानक योजनाओं के बीच एक सुनसान रास्ता बनाने और प्रतिस्पर्धात्मक अनुप्रयोगों के काम के पहले से ही डिबग किए गए तर्क की नकल करने का एक बड़ा अवसर था, जबकि थोड़ा सा गैग जोड़ते हुए। लेकिन मेटाडेटा के अनुरोधों का विश्लेषण करने के बाद, मैं कुछ और अनुकूलित करना चाहता था, जो कि बड़ी कंपनियों की नौकरशाही के कारण कभी भी उनके उत्पादों में दिखाई नहीं देता था।

RedGate SQL Index Manager (1.1.9.1378 - $ 155) का विश्लेषण करते समय, आप देख सकते हैं कि एप्लिकेशन बहुत ही सरल दृष्टिकोण का उपयोग करता है: एक क्वेरी के साथ हमें उपयोगकर्ता तालिकाओं और विचारों की एक सूची मिलती है, और दूसरी क्वेरी के बाद, चयनित डेटाबेस के भीतर सभी सूची की सूची वापस आ जाती है।

SELECT objects.name AS tableOrViewName , objects.object_id AS tableOrViewId , schemas.name AS schemaName , CAST(ISNULL(lobs.NumLobs, 0) AS BIT) AS ContainsLobs , o.is_memory_optimized FROM sys.objects AS objects JOIN sys.schemas AS schemas ON schemas.schema_id = objects.schema_id LEFT JOIN ( SELECT object_id , COUNT(*) AS NumLobs FROM sys.columns WITH (NOLOCK) WHERE system_type_id IN (34, 35, 99) OR max_length = -1 GROUP BY object_id ) AS lobs ON objects.object_id = lobs.object_id LEFT JOIN sys.tables AS o ON o.object_id = objects.object_id WHERE objects.type = 'U' OR objects.type = 'V' SELECT i.object_id AS tableOrViewId , i.name AS indexName , i.index_id AS indexId , i.allow_page_locks AS allowPageLocks , p.partition_number AS partitionNumber , CAST((c.numPartitions - 1) AS BIT) AS belongsToPartitionedIndex FROM sys.indexes AS i JOIN sys.partitions AS p ON p.index_id = i.index_id AND p.object_id = i.object_id JOIN ( SELECT COUNT(*) AS numPartitions , object_id , index_id FROM sys.partitions GROUP BY object_id , index_id ) AS c ON c.index_id = i.index_id AND c.object_id = i.object_id WHERE i.index_id > 0 -- ignore heaps AND i.is_disabled = 0 AND i.is_hypothetical = 0

फिर, एक चक्र में, सूचकांक के प्रत्येक अनुभाग के लिए, इसके आकार और विखंडन के स्तर को निर्धारित करने के लिए एक अनुरोध भेजा जाता है। स्कैन के अंत में, एंट्री थ्रेशोल्ड से कम वजन वाले इंडेक्स क्लाइंट पर छोड़ दिए जाते हैं।

 EXEC sp_executesql N' SELECT index_id, avg_fragmentation_in_percent, page_count FROM sys.dm_db_index_physical_stats(@databaseId, @objectId, @indexId, @partitionNr, NULL)' , N'@databaseId int,@objectId int,@indexId int,@partitionNr int' , @databaseId = 7, @objectId = 2133582639, @indexId = 1, @partitionNr = 1 EXEC sp_executesql N' SELECT index_id, avg_fragmentation_in_percent, page_count FROM sys.dm_db_index_physical_stats(@databaseId, @objectId, @indexId, @partitionNr, NULL)' , N'@databaseId int,@objectId int,@indexId int,@partitionNr int' , @databaseId = 7, @objectId = 2133582639, @indexId = 2, @partitionNr = 1 EXEC sp_executesql N' SELECT index_id, avg_fragmentation_in_percent, page_count FROM sys.dm_db_index_physical_stats(@databaseId, @objectId, @indexId, @partitionNr, NULL)' , N'@databaseId int,@objectId int,@indexId int,@partitionNr int' , @databaseId = 7, @objectId = 2133582639, @indexId = 3, @partitionNr = 1

इस एप्लिकेशन के तर्क का विश्लेषण करते समय, आप कई कमियां पा सकते हैं। उदाहरण के लिए, यदि आपको ट्रिफ़ल्स के साथ गलती मिलती है, तो अनुरोध भेजने से पहले, इस बारे में कोई जांच नहीं की जाती है कि क्या वर्तमान खंड में स्कैनिंग से खाली वर्गों को बाहर करने के लिए तार हैं।

लेकिन समस्या एक और पहलू में सबसे अधिक तीव्र है: सर्वर अनुरोधों की संख्या लगभग sys.partitions से कुल पंक्तियों की संख्या के बराबर होगी। इस तथ्य को देखते हुए कि वास्तविक डेटाबेस में दसियों हजार खंड हो सकते हैं, इस बारीकियों से सर्वर को समान अनुरोधों की एक बड़ी संख्या हो सकती है। ऐसी स्थिति में जब डेटाबेस दूरस्थ होता है, तो स्कैन का समय प्रत्येक के लिए नेटवर्क विलंब बढ़ने के कारण और भी सरल हो जाएगा, यहां तक कि सबसे सरल, अनुरोध

RedGate के विपरीत, Devart में विकसित एक समान उत्पाद - dbForge Index Manager for SQL Server (1.10.38 - $ 99) एक बड़ी क्वेरी में जानकारी प्राप्त करता है और फिर क्लाइंट पर सब कुछ प्रदर्शित करता है:

 SELECT SCHEMA_NAME(o.[schema_id]) AS [schema_name] , o.name AS parent_name , o.[type] AS parent_type , i.name , i.type_desc , s.avg_fragmentation_in_percent , s.page_count , p.partition_number , p.[rows] , ISNULL(lob.is_lob_legacy, 0) AS is_lob_legacy , ISNULL(lob.is_lob, 0) AS is_lob , CASE WHEN ds.[type] = 'PS' THEN 1 ELSE 0 END AS is_partitioned FROM sys.dm_db_index_physical_stats(DB_ID(), NULL, NULL, NULL, NULL) s JOIN sys.partitions p ON s.[object_id] = p.[object_id] AND s.index_id = p.index_id AND s.partition_number = p.partition_number JOIN sys.indexes i ON i.[object_id] = s.[object_id] AND i.index_id = s.index_id LEFT JOIN ( SELECT c.[object_id] , index_id = ISNULL(i.index_id, 1) , is_lob_legacy = MAX(CASE WHEN c.system_type_id IN (34, 35, 99) THEN 1 END) , is_lob = MAX(CASE WHEN c.max_length = -1 THEN 1 END) FROM sys.columns c LEFT JOIN sys.index_columns i ON c.[object_id] = i.[object_id] AND c.column_id = i.column_id AND i.index_id > 0 WHERE c.system_type_id IN (34, 35, 99) OR c.max_length = -1 GROUP BY c.[object_id], i.index_id ) lob ON lob.[object_id] = i.[object_id] AND lob.index_id = i.index_id JOIN sys.objects o ON o.[object_id] = i.[object_id] JOIN sys.data_spaces ds ON i.data_space_id = ds.data_space_id WHERE i.[type] IN (1, 2) AND i.is_disabled = 0 AND i.is_hypothetical = 0 AND s.index_level = 0 AND s.alloc_unit_type_desc = 'IN_ROW_DATA' AND o.[type] IN ('U', 'V')

हम एक प्रतिस्पर्धी उत्पाद में एक ही प्रकार के प्रश्नों के घूंघट के साथ मुख्य समस्या से छुटकारा पाने में कामयाब रहे, लेकिन इस कार्यान्वयन का नुकसान यह है कि कोई अतिरिक्त पैरामीटर sysinos_db_index_physical_stic फ़ंक्शन को पारित नहीं किया जाता है जो स्पष्ट रूप से अनावश्यक अनुक्रमित की स्कैनिंग को सीमित कर सकते हैं। वास्तव में, यह सिस्टम के सभी सूचकांकों और स्कैनिंग चरण पर अतिरिक्त डिस्क लोड की जानकारी प्राप्त करने की ओर जाता है।

यह ध्यान रखना महत्वपूर्ण है कि sysinos_db_index_physical_stats से प्राप्त डेटा को बफ़र पूल में स्थायी रूप से कैश नहीं किया जाता है, इसलिए, इंडेक्स फ़्रेग्मेंटेशन के बारे में जानकारी प्राप्त करते समय भौतिक रीडिंग को कम करना विकास के दौरान प्राथमिकता में से एक था।

कई प्रयोगों के बाद, यह दोनों दृष्टिकोणों को संयोजित करने के लिए निकला, स्कैन को दो भागों में विभाजित किया गया। सबसे पहले, एक बड़ी क्वेरी वर्गों के आकार को निर्धारित करती है, जो फ़िल्टरिंग रेंज में नहीं हैं, उन्हें पूर्व फ़िल्टर करना:

 INSERT INTO #AllocationUnits (ContainerID, ReservedPages, UsedPages) SELECT [container_id] , SUM([total_pages]) , SUM([used_pages]) FROM sys.allocation_units WITH(NOLOCK) GROUP BY [container_id] HAVING SUM([total_pages]) BETWEEN @MinIndexSize AND @MaxIndexSize

अगला, हमें केवल वे अनुभाग मिलते हैं जिनमें खाली अनुक्रमित से अनावश्यक रीड ऑपरेशंस से बचने के लिए डेटा होता है।

 SELECT [object_id] , [index_id] , [partition_id] , [partition_number] , [rows] , [data_compression] INTO #Partitions FROM sys.partitions WITH(NOLOCK) WHERE [object_id] > 255 AND [rows] > 0 AND [object_id] NOT IN (SELECT * FROM #ExcludeList)

सेटिंग्स के आधार पर, केवल उन प्रकार के अनुक्रमित प्राप्त किए जाते हैं जो उपयोगकर्ता विश्लेषण करना चाहता है (हीप्स, क्लस्टर / नॉन-क्लस्टर इंडेक्स के साथ काम करना, और कॉलम संकेतक समर्थित है)।

 INSERT INTO #Indexes SELECT ObjectID = i.[object_id] , IndexID = i.index_id , IndexName = i.[name] , PagesCount = a.ReservedPages , UnusedPagesCount = a.ReservedPages - a.UsedPages , PartitionNumber = p.[partition_number] , RowsCount = ISNULL(p.[rows], 0) , IndexType = i.[type] , IsAllowPageLocks = i.[allow_page_locks] , DataSpaceID = i.[data_space_id] , DataCompression = p.[data_compression] , IsUnique = i.[is_unique] , IsPK = i.[is_primary_key] , FillFactorValue = i.[fill_factor] , IsFiltered = i.[has_filter] FROM #AllocationUnits a JOIN #Partitions p ON a.ContainerID = p.[partition_id] JOIN sys.indexes i WITH(NOLOCK) ON i.[object_id] = p.[object_id] AND p.[index_id] = i.[index_id] WHERE i.[type] IN (0, 1, 2, 5, 6) AND i.[object_id] > 255

इसके बाद, थोड़ा जादू शुरू होता है: सभी छोटे सूचकांकों के लिए, हम सभी मापदंडों के पूर्ण संकेत के साथ बार-बार sysinos_db_index_physical_stats फ़ंक्शन को कॉल करके विखंडन के स्तर को निर्धारित करते हैं।

 INSERT INTO #Fragmentation (ObjectID, IndexID, PartitionNumber, Fragmentation) SELECT i.ObjectID , i.IndexID , i.PartitionNumber , r.[avg_fragmentation_in_percent] FROM #Indexes i CROSS APPLY sys.dm_db_index_physical_stats(@DBID, i.ObjectID, i.IndexID, i.PartitionNumber, 'LIMITED') r WHERE i.PagesCount <= @PreDescribeSize AND r.[index_level] = 0 AND r.[alloc_unit_type_desc] = 'IN_ROW_DATA' AND i.IndexType IN (0, 1, 2)

अगला, हम ग्राहक को सभी संभावित जानकारी लौटाते हैं, अतिरिक्त डेटा को फ़िल्टर करते हैं:

 SELECT i.ObjectID , i.IndexID , i.IndexName , ObjectName = o.[name] , SchemaName = s.[name] , i.PagesCount , i.UnusedPagesCount , i.PartitionNumber , i.RowsCount , i.IndexType , i.IsAllowPageLocks , u.TotalWrites , u.TotalReads , u.TotalSeeks , u.TotalScans , u.TotalLookups , u.LastUsage , i.DataCompression , f.Fragmentation , IndexStats = STATS_DATE(i.ObjectID, i.IndexID) , IsLobLegacy = ISNULL(lob.IsLobLegacy, 0) , IsLob = ISNULL(lob.IsLob, 0) , IsSparse = CAST(CASE WHEN p.ObjectID IS NULL THEN 0 ELSE 1 END AS BIT) , IsPartitioned = CAST(CASE WHEN dds.[data_space_id] IS NOT NULL THEN 1 ELSE 0 END AS BIT) , FileGroupName = fg.[name] , i.IsUnique , i.IsPK , i.FillFactorValue , i.IsFiltered , a.IndexColumns , a.IncludedColumns FROM #Indexes i JOIN sys.objects o WITH(NOLOCK) ON o.[object_id] = i.ObjectID JOIN sys.schemas s WITH(NOLOCK) ON s.[schema_id] = o.[schema_id] LEFT JOIN #AggColumns a ON a.ObjectID = i.ObjectID AND a.IndexID = i.IndexID LEFT JOIN #Sparse p ON p.ObjectID = i.ObjectID LEFT JOIN #Fragmentation f ON f.ObjectID = i.ObjectID AND f.IndexID = i.IndexID AND f.PartitionNumber = i.PartitionNumber LEFT JOIN ( SELECT ObjectID = [object_id] , IndexID = [index_id] , TotalWrites = NULLIF([user_updates], 0) , TotalReads = NULLIF([user_seeks] + [user_scans] + [user_lookups], 0) , TotalSeeks = NULLIF([user_seeks], 0) , TotalScans = NULLIF([user_scans], 0) , TotalLookups = NULLIF([user_lookups], 0) , LastUsage = ( SELECT MAX(dt) FROM ( VALUES ([last_user_seek]) , ([last_user_scan]) , ([last_user_lookup]) , ([last_user_update]) ) t(dt) ) FROM sys.dm_db_index_usage_stats WITH(NOLOCK) WHERE [database_id] = @DBID ) u ON i.ObjectID = u.ObjectID AND i.IndexID = u.IndexID LEFT JOIN #Lob lob ON lob.ObjectID = i.ObjectID AND lob.IndexID = i.IndexID LEFT JOIN sys.destination_data_spaces dds WITH(NOLOCK) ON i.DataSpaceID = dds.[partition_scheme_id] AND i.PartitionNumber = dds.[destination_id] JOIN sys.filegroups fg WITH(NOLOCK) ON ISNULL(dds.[data_space_id], i.DataSpaceID) = fg.[data_space_id] WHERE o.[type] IN ('V', 'U') AND ( f.Fragmentation >= @Fragmentation OR i.PagesCount > @PreDescribeSize OR i.IndexType IN (5, 6) )

इसके बाद, बिंदु प्रश्न बड़े सूचकांकों के लिए विखंडन के स्तर को निर्धारित करते हैं।

 EXEC sp_executesql N' DECLARE @DBID INT = DB_ID() SELECT [avg_fragmentation_in_percent] FROM sys.dm_db_index_physical_stats(@DBID, @ObjectID, @IndexID, @PartitionNumber, ''LIMITED'') WHERE [index_level] = 0 AND [alloc_unit_type_desc] = ''IN_ROW_DATA''' , N'@ObjectID int,@IndexID int,@PartitionNumber int' , @ObjectId = 1044198770, @IndexId = 1, @PartitionNumber = 1 EXEC sp_executesql N' DECLARE @DBID INT = DB_ID() SELECT [avg_fragmentation_in_percent] FROM sys.dm_db_index_physical_stats(@DBID, @ObjectID, @IndexID, @PartitionNumber, ''LIMITED'') WHERE [index_level] = 0 AND [alloc_unit_type_desc] = ''IN_ROW_DATA''' , N'@ObjectID int,@IndexID int,@PartitionNumber int' , @ObjectId = 1552724584, @IndexId = 0, @PartitionNumber = 1

इस दृष्टिकोण के कारण, जब प्रश्न उत्पन्न होते हैं, तो स्कैनिंग के प्रदर्शन के साथ समस्याओं को हल करना संभव था जो प्रतियोगियों के अनुप्रयोगों में सामने आए थे। इसे पूरा किया जा सकता है, लेकिन विकास की प्रक्रिया में, नए विचार धीरे-धीरे प्रकट हुए जो आपके उत्पाद के आवेदन के दायरे का विस्तार करने की अनुमति देते हैं।

प्रारंभ में, WAIT_AT_LOW_PRIORITY के साथ काम करने के लिए समर्थन लागू किया गया था, फिर सूचकांकों के पुनर्निर्माण के लिए DATA_COMPRESSION और FILL_FACTOR का उपयोग करना संभव हो गया।

SQL सूचकांक प्रबंधक सेटिंग्स

आवेदन पहले से अनियोजित कार्यक्षमता के साथ थोड़ा आगे बढ़ गया था, जैसे सर्विसिंग कॉलमस्टोर:

 SELECT * FROM ( SELECT IndexID = [index_id] , PartitionNumber = [partition_number] , PagesCount = SUM([size_in_bytes]) / 8192 , UnusedPagesCount = ISNULL(SUM(CASE WHEN [state] = 1 THEN [size_in_bytes] END), 0) / 8192 , Fragmentation = CAST(ISNULL(SUM(CASE WHEN [state] = 1 THEN [size_in_bytes] END), 0) * 100. / SUM([size_in_bytes]) AS FLOAT) FROM sys.fn_column_store_row_groups(@ObjectID) GROUP BY [index_id] , [partition_number] ) t WHERE Fragmentation >= @Fragmentation AND PagesCount BETWEEN @MinIndexSize AND @MaxIndexSize

या dm_db_missing_index की जानकारी के आधार पर गैर-क्लस्टर इंडेक्स बनाने की क्षमता:

 SELECT ObjectID = d.[object_id] , UserImpact = gs.[avg_user_impact] , TotalReads = gs.[user_seeks] + gs.[user_scans] , TotalSeeks = gs.[user_seeks] , TotalScans = gs.[user_scans] , LastUsage = ISNULL(gs.[last_user_scan], gs.[last_user_seek]) , IndexColumns = CASE WHEN d.[equality_columns] IS NOT NULL AND d.[inequality_columns] IS NOT NULL THEN d.[equality_columns] + ', ' + d.[inequality_columns] WHEN d.[equality_columns] IS NOT NULL AND d.[inequality_columns] IS NULL THEN d.[equality_columns] ELSE d.[inequality_columns] END , IncludedColumns = d.[included_columns] FROM sys.dm_db_missing_index_groups g WITH(NOLOCK) JOIN sys.dm_db_missing_index_group_stats gs WITH(NOLOCK) ON gs.[group_handle] = g.[index_group_handle] JOIN sys.dm_db_missing_index_details d WITH(NOLOCK) ON g.[index_handle] = d.[index_handle] WHERE d.[database_id] = DB_ID()

परिणाम

छह महीने के सक्रिय विकास के चरण के बाद, मुझे खुशी है कि योजनाएं समाप्त नहीं हुई हैं, क्योंकि मैं इस उत्पाद को और विकसित करना चाहता हूं। अगला कदम डुप्लिकेट या अप्रयुक्त इंडेक्स की खोज के लिए कार्यक्षमता जोड़ना है, साथ ही साथ SQL सर्वर पर डेटा की सेवा के लिए पूर्ण समर्थन को लागू करना है।

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

आवेदन का वर्तमान संस्करण GitHub पर डाउनलोड किया जा सकता है । स्रोत एक ही स्थान पर हैं।

एसक्यूएल इंडेक्स मैनेजर - इंडेक्स को डीफ़्रैग्मेन्ट करने और बनाए रखने के लिए एक मुफ्त टूल

विचार

कार्यान्वयन

परिणाम

More articles: