sys.allocation_units और sp_spaceused पर अंतरिक्ष उपयोग


13

यह एक ज्ञात तथ्य है कि डीएमवी पृष्ठों की संख्या और पंक्तियों की गिनती के बारे में सटीक जानकारी नहीं रखते हैं। हालाँकि, जब आपके पास आँकड़े अपडेट होते हैं, तो मैं यह नहीं देख सकता कि वे क्यों नहीं करेंगे।

मैं एक निगरानी उपकरण पर काम कर रहा हूं, प्रत्येक सूचकांक और डेटा का डिस्क आकार जानना चाहता हूं, आदि। आखिरकार मैं सही भरण कारक, और अन्य चीजें आदि ढूंढना चाहता हूं।

मेरे फ़ंक्शन और पुराने sp_spaceused द्वारा उपयोग किया जाने वाला स्थान अंतरिक्ष उपयोग पर थोड़ा भिन्न होता है, लेकिन रिकॉर्ड गणना पर नहीं।

क्या आप देख सकते हैं कि मेरे चयन में कुछ कमी है?

यह sp_spaceused है (फिर मैं एमबी में संख्याओं को परिवर्तित करता हूं):

sp_spaceused 'tblBOrderRelationship'
go

select 318008/1024.00 AS reserved,
140208/1024.00  AS data,
177048/1024.00 AS index_size,
752/1024.00    AS unused

यहाँ छवि विवरण दर्ज करें

लेकिन जब मैं अपना चयन करता हूं, नीचे \ पिक्चर के नीचे का कोड, मुझे थोड़ा अलग आंकड़े मिलते हैं।

SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED

SELECT 
    schema_name(t.schema_id) as SchemaName,
    t.NAME AS TableName,
    t.type_desc,
    t.is_ms_shipped,
    t.is_published,
    t.lob_data_space_id,
    t.filestream_data_space_id,
    t.is_replicated,
    t.has_replication_filter,
    t.is_merge_published,
    t.is_sync_tran_subscribed,
    --t.is_filetable,
    i.name as indexName,
    i.type_desc,
    i.is_unique,
    i.is_primary_key,
    i.is_unique_constraint,
    i.fill_factor,
    i.is_padded,


    sum(p.rows)               OVER (PARTITION BY t.OBJECT_ID,i.index_id)  as RowCounts,
    sum(a.total_pages)        OVER (PARTITION BY t.OBJECT_ID,i.index_id)  as TotalPages, 
    sum(a.used_pages)         OVER (PARTITION BY t.OBJECT_ID,i.index_id)  as UsedPages, 
    sum(a.data_pages)         OVER (PARTITION BY t.OBJECT_ID,i.index_id)  as DataPages,

    (sum(a.total_pages)       OVER (PARTITION BY t.OBJECT_ID,i.index_id)  * 8) / 1024 as TotalSpaceMB, 
    (sum(a.used_pages)        OVER (PARTITION BY t.OBJECT_ID,i.index_id)  * 8) / 1024 as UsedSpaceMB, 
    (sum(a.data_pages)        OVER (PARTITION BY t.OBJECT_ID,i.index_id)  * 8) / 1024 as DataSpaceMB
FROM 
    sys.tables t
INNER JOIN      
    sys.indexes i ON t.OBJECT_ID = i.object_id
INNER JOIN 
    sys.partitions p ON i.object_id = p.OBJECT_ID AND i.index_id = p.index_id
INNER JOIN 
    sys.allocation_units a ON p.partition_id = a.container_id
WHERE 
    t.NAME NOT LIKE 'dt%' AND
    i.OBJECT_ID > 255 
AND T.NAME = 'tblBOrderRelationship'

आंकड़े

आंकड़े

सूचकांक नामों सहित बड़ी तस्वीर सूचकांक नामों सहित बड़ी तस्वीर

अब परिणामों की जाँच करने के लिए कुछ गणनाएँ कर रहे हैं:

--==================================
-- the figures from sp_spaceused
--==================================
select 318008/1024.00 AS reserved,
140208/1024.00  AS data,
177048/1024.00 AS index_size,
752/1024.00    AS unused

--==================================
-- the figures from my select
--==================================
select 137+61+56+54 AS reserved,
       137 AS data,
       61+56+54 AS index_size

यहाँ छवि विवरण दर्ज करें

यह इतनी दूर नहीं है, वास्तव में, इस तथ्य के अलावा मैंने अप्रयुक्त स्थान की गणना नहीं की है!

इसे सटीक बनाने के लिए मैं क्या कर सकता हूं?

परिवर्तन के बाद:

जब मैंने 1024 को 1024.00 से बदल दिया तो परिणाम बहुत अधिक सटीक हैं। मैंने देखा कि रिकॉर्ड को प्रश्न में तालिका में डाला गया है, और जाहिर है कि आँकड़े आज तक नहीं हैं, लेकिन फिर भी परिणाम मेल खाते हैं (1 एमबी अंतर के तहत - जो मेरे लिए सब ठीक है)

नए परिणाम सेट निम्न हैं:

--==================================
-- the figures from sp_spaceused
--==================================
select
318072 /1024.00 AS reserved,
140208 /1024.00 AS data,
177096 /1024.00 AS index_size,
768 /1024.00 AS unused
go

--==================================
-- the figures from my select
--==================================
select 137.7578125+61.7968750+56.4218750+54.6406250 as reserved,
       137.7578125 as data,
       61.7968750+56.4218750+54.6406250 as index_size

यहाँ छवि विवरण दर्ज करें

जवाबों:


24

भले ही आपने तत्काल राउंडिंग समस्या को ठीक कर दिया हो, लेकिन प्रति-ऑब्जेक्ट / इंडेक्स आँकड़े प्राप्त करने के लिए समग्र एल्गोरिथ्म गलत है। यह LOB और पंक्ति-अतिप्रवाह डेटा को ठीक से हैंडल नहीं करता है। यह भी शामिल नहीं है: अनुक्रमित दृश्य, FullText अनुक्रमित, XML अनुक्रमित, और कुछ अन्य मामलों। इसलिए, हो सकता है कि आप अपने सभी डेटा को नहीं देख रहे हों।

निम्नलिखित कोड का एक अनुकूलन है जिसे मैंने StackOverflow ( sp_spaceused - SQL में सभी तालिकाओं में GB में आकार कैसे मापें ) के सभी मामलों को sp_spaceusedहैंडल करता है। वह SO प्रश्न केवल प्रति-वस्तु आँकड़े से संबंधित था, प्रति अनुक्रमणिका से नहीं, इसलिए मैंने अनुक्रमणिका स्तर पर चीजों को संभालने के लिए कोड को समायोजित किया है।

;WITH agg AS
(   -- Get info for Tables, Indexed Views, etc
    SELECT  ps.[object_id] AS [ObjectID],
            ps.index_id AS [IndexID],
            NULL AS [ParentIndexID],
            NULL AS [PassThroughIndexName],
            NULL AS [PassThroughIndexType],
            SUM(ps.in_row_data_page_count) AS [InRowDataPageCount],
            SUM(ps.used_page_count) AS [UsedPageCount],
            SUM(ps.reserved_page_count) AS [ReservedPageCount],
            SUM(ps.row_count) AS [RowCount],
            SUM(ps.lob_used_page_count + ps.row_overflow_used_page_count)
                    AS [LobAndRowOverflowUsedPageCount]
    FROM    sys.dm_db_partition_stats ps
    GROUP BY    ps.[object_id],
                ps.[index_id]
    UNION ALL
    -- Get info for FullText indexes, XML indexes, Spatial indexes, etc
    SELECT  sit.[parent_id] AS [ObjectID],
            sit.[object_id] AS [IndexID],
            sit.[parent_minor_id] AS [ParentIndexID],
            sit.[name] AS [PassThroughIndexName],
            sit.[internal_type_desc] AS [PassThroughIndexType],
            0 AS [InRowDataPageCount],
            SUM(ps.used_page_count) AS [UsedPageCount],
            SUM(ps.reserved_page_count) AS [ReservedPageCount],
            0 AS [RowCount],
            0 AS [LobAndRowOverflowUsedPageCount]
    FROM    sys.dm_db_partition_stats ps
    INNER JOIN  sys.internal_tables sit
            ON  sit.[object_id] = ps.[object_id]
    WHERE   sit.internal_type IN
               (202, 204, 207, 211, 212, 213, 214, 215, 216, 221, 222, 236)
    GROUP BY    sit.[parent_id],
                sit.[object_id],
                sit.[parent_minor_id],
                sit.[name],
                sit.[internal_type_desc]
), spaceused AS
(
SELECT  agg.[ObjectID],
        agg.[IndexID],
        agg.[ParentIndexID],
        agg.[PassThroughIndexName],
        agg.[PassThroughIndexType],
        OBJECT_SCHEMA_NAME(agg.[ObjectID]) AS [SchemaName],
        OBJECT_NAME(agg.[ObjectID]) AS [TableName],
        SUM(CASE
                WHEN (agg.IndexID < 2) THEN agg.[RowCount]
                ELSE 0
            END) AS [Rows],
        SUM(agg.ReservedPageCount) * 8 AS [ReservedKB],
        SUM(agg.LobAndRowOverflowUsedPageCount +
            CASE
                WHEN (agg.IndexID < 2) THEN (agg.InRowDataPageCount)
                ELSE 0
            END) * 8 AS [DataKB],
        SUM(agg.UsedPageCount - agg.LobAndRowOverflowUsedPageCount -
            CASE
                WHEN (agg.IndexID < 2) THEN agg.InRowDataPageCount
                ELSE 0
            END) * 8 AS [IndexKB],
        SUM(agg.ReservedPageCount - agg.UsedPageCount) * 8 AS [UnusedKB],
        SUM(agg.UsedPageCount) * 8 AS [UsedKB]
FROM    agg
GROUP BY    agg.[ObjectID],
            agg.[IndexID],
            agg.[ParentIndexID],
            agg.[PassThroughIndexName],
            agg.[PassThroughIndexType],
            OBJECT_SCHEMA_NAME(agg.[ObjectID]),
            OBJECT_NAME(agg.[ObjectID])
)
SELECT sp.SchemaName,
       sp.TableName,
       sp.IndexID,
       CASE
         WHEN (sp.IndexID > 0) THEN COALESCE(si.[name], sp.[PassThroughIndexName])
         ELSE N'<Heap>'
       END AS [IndexName],
       sp.[PassThroughIndexName] AS [InternalTableName],
       sp.[Rows],
       sp.ReservedKB,
       (sp.ReservedKB / 1024.0 / 1024.0) AS [ReservedGB],
       sp.DataKB,
       (sp.DataKB / 1024.0 / 1024.0) AS [DataGB],
       sp.IndexKB,
       (sp.IndexKB / 1024.0 / 1024.0) AS [IndexGB],
       sp.UsedKB AS [UsedKB],
       (sp.UsedKB / 1024.0 / 1024.0) AS [UsedGB],
       sp.UnusedKB,
       (sp.UnusedKB / 1024.0 / 1024.0) AS [UnusedGB],
       so.[type_desc] AS [ObjectType],
       COALESCE(si.type_desc, sp.[PassThroughIndexType]) AS [IndexPrimaryType],
       sp.[PassThroughIndexType] AS [IndexSecondaryType],
       SCHEMA_ID(sp.[SchemaName]) AS [SchemaID],
       sp.ObjectID
       --,sp.ParentIndexID
FROM   spaceused sp
INNER JOIN sys.all_objects so -- in case "WHERE so.is_ms_shipped = 0" is removed
        ON so.[object_id] = sp.ObjectID
LEFT JOIN  sys.indexes si
       ON  si.[object_id] = sp.ObjectID
      AND  (si.[index_id] = sp.IndexID
         OR si.[index_id] = sp.[ParentIndexID])
WHERE so.is_ms_shipped = 0
--so.[name] LIKE N''  -- optional name filter
--ORDER BY ????

8

आप इसे विभाजित कर रहे हैं INTताकि आपको केवल एक पूरी संख्या में उत्तर मिल सके।

इसलिए आप अपने स्वयं के अंतरिक्ष गणना पर एक गोल समस्या के साथ समाप्त होते हैं। यही कारण है, जब आप उन्हें एक साथ जोड़ते हैं, तो आपको एक अलग उत्तर मिलता है।

हालांकि यह अंतर न्यूनतम है कि यह SQL सर्वर में गैर-संपूर्ण संख्याओं को संभालने के साथ उन प्रमुख 'गोच' में से एक है।

प्रक्रिया में अपनी विभाजन क्वेरी बदलें:

(sum(a.total_pages)       OVER (PARTITION BY t.OBJECT_ID,i.index_id)  * 8) / 1024.00 as TotalSpaceMB, 
(sum(a.used_pages)        OVER (PARTITION BY t.OBJECT_ID,i.index_id)  * 8) / 1024.00 as UsedSpaceMB, 
(sum(a.data_pages)        OVER (PARTITION BY t.OBJECT_ID,i.index_id)  * 8) / 1024.00 as DataSpaceMB
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.