Gibt es eine Möglichkeit, die Größe/Größe Ihrer Datenbanktabellen herauszufinden?

Question

Ich habe ungefähr 10 Tabellen in meinem SQL 2008 Server.

Derzeit ist mein MDF etwa 3.5Gig. (Ich habe auch einige Binärdaten in einigen der Tabellen). Also, ich frage mich, ob es einen Weg gibt, um zu sehen, welche Tische am größten sind.

Ist das möglich?

Vielleicht ist es stattdessen ein Index oder FTS-Katalog?

Answer 1

laufen diese:

/****************************************************************************** 
** File: “GetTableSpaceUseage.sql” 
** Name: Get Table Space Useage for a specific schema 
** Auth: Robert C. Cain 
** Date: 01/27/2008 
** 
** Desc: Calls the sp_spaceused proc for each table in a schema and returns 
**  the Table Name, Number of Rows, and space used for each table. 
** 
** Called by: 
**  n/a – As needed 
** 
** Input Parameters: 
**  In the code check the value of @schemaname, if you need it for a 
**  schema other than dbo be sure to change it. 
** 
** Output Parameters: 
**  NA 
*******************************************************************************/ 

/*—————————————————————————*/ 
/* Drop the temp table if it's there from a previous run      */ 
/*—————————————————————————*/ 
if object_id(N'tempdb..[#TableSizes]') is not null 
    drop table #TableSizes ; 
go 

/*—————————————————————————*/ 
/* Create the temp table              */ 
/*—————————————————————————*/ 
create table #TableSizes 
    (
    [Table Name] nvarchar(128) /* Name of the table */ 
    , [Number of Rows] char(11) /* Number of rows existing in the table. */ 
    , [Reserved Space] varchar(18) /* Reserved space for table. */ 
    , [Data Space] varchar(18) /* Amount of space used by data in table. */ 
    , [Index Size] varchar(18) /* Amount of space used by indexes in table. */ 
    , [Unused Space] varchar(18) /* Amount of space reserved but not used. */ 
) ; 
go 

/*—————————————————————————*/ 
/* Load the temp table              */ 
/*—————————————————————————*/ 
declare @schemaname varchar(256) ; 
-- Make sure to set next line to the Schema name you want! 
set @schemaname = 'dbo' ; 

-- Create a cursor to cycle through the names of each table in the schema 
declare curSchemaTable cursor 
    for select sys.schemas.name + '.' + sys.objects.name 
     from sys.objects 
      , sys.schemas 
     where object_id > 100 
       and sys.schemas.name = @schemaname 
       /* For a specific table uncomment next line and supply name */ 
       --and sys.objects.name = 'specific-table-name-here'  
       and type_desc = 'USER_TABLE' 
       and sys.objects.schema_id = sys.schemas.schema_id ; 

open curSchemaTable ; 
declare @name varchar(256) ; /* This holds the name of the current table*/ 

-- Now loop thru the cursor, calling the sp_spaceused for each table 
fetch curSchemaTable into @name ; 
while (@@FETCH_STATUS = 0) 
    begin  
    insert into #TableSizes 
      exec sp_spaceused @objname = @name ;  
    fetch curSchemaTable into @name ; 
    end 

/* Important to both close and deallocate! */ 
close curSchemaTable ;  
deallocate curSchemaTable ; 


/*—————————————————————————*/ 
/* Feed the results back              */ 
/*—————————————————————————*/ 
select [Table Name] 
     , [Number of Rows] 
     , [Reserved Space] 
     , [Data Space] 
     , [Index Size] 
     , [Unused Space] 
from [#TableSizes] 
order by [Table Name] ; 

/*—————————————————————————*/ 
/* Remove the temp table              */ 
/*—————————————————————————*/ 
drop table #TableSizes ; 

taken von Robert Caine Blog

der Code Herausgegeben zu analysieren, einige Zeichen, die in einfache Anführungszeichen verwendet, um eine spezielle Apostroph, wie auch die -- Schild.

Dieser Code ist für Microsoft SQL 2005+

Answer 2

exec sp_spaceused <tablename> 

Answer 3

exec sp_spaceused [tablename] 

Answer 4

Manchmal habe ich diese laufen ... Es alle Tabellen temporäre Tabelle wird, schleift sie durch und bekommt Größen für alle Tabellen. Die Ergebnisdaten befinden sich in @tablesizes, so dass Sie sie wie gewünscht abfragen können.

Arbeiten in SQL Server> 2005

declare @tables TABLE 
(
    table_name nvarchar(200) 
) 

declare @tablesizes TABLE 
(
    [name] nvarchar(200), 
    [rows] int, 
    reserved nvarchar(200), 
    data nvarchar(200), 
    index_size nvarchar(200), 
    unused nvarchar(200), 
    reserved_int int, 
    data_int int, 
    index_size_int int, 
    unused_int int 
) 

declare @t nvarchar(200) 

insert into @tables 
select Table_Name from information_schema.tables 

while exists(select * from @tables) 
begin 
    set @t=(select top 1 table_name from @tables) 

    insert into @tablesizes([name],[rows],reserved,data,index_size,unused) 
    exec sp_spaceused @t 

    delete top (1) from @tables 
end 

update @tablesizes set 
reserved_int=convert(int, replace(reserved,' KB','')), 
data_int=convert(int, replace(data,' KB','')), 
index_size_int=convert(int, replace(index_size,' KB','')), 
unused_int=convert(int, replace(unused,' KB','')) 

select * from @tablesizes order by data_int desc 

Answer 5

sys.allocations_units hat die Informationen, die Sie benötigen. Sie verbinden sich mit sys.partitions, um alle Zuordnungseinheiten einer Partition zusammenzufassen und auch die besser nutzbare object_id als die esoterische allocation_unit_id zu erhalten.

select object_name(p.object_id), 
    sum(au.total_pages)*8 as [space_in_kb] 
    from sys.partitions p 
    join sys.allocation_units au on p.hobt_id = au.container_id 
    group by p.object_id 
    order by [space_in_kb] desc 

Und ja, alle Tabellen (Heap oder gruppierten) sind ‚partitions‘, die Begriffe bezieht sich nicht auf partitionierten Tabellen. sys.partitions enthält auch die Spalte "rows", die Sie interessieren könnte.

Answer 6

Diese Abfrage zeigt die Größe jeder Tabelle in der aktuellen Datenbank an.

SELECT sysobjects.[name] AS [TableName], 
    SUM(sysindexes.reserved) * 8 AS [Size(KB)], 
    SUM(sysindexes.dpages) * 8 AS [Data(KB)], 
    (SUM(sysindexes.used) - SUM(sysindexes.dpages)) * 8 AS [Indexes(KB)], 
    (SUM(sysindexes.reserved) - SUM(sysindexes.dpages)) * 8 AS [Unused(KB)] 
FROM dbo.sysindexes AS sysindexes 
    JOIN dbo.sysobjects AS sysobjects ON sysobjects.id = sysindexes.id 
WHERE sysobjects.[type] = 'U' 
GROUP BY sysobjects.[name] 
ORDER BY [Size(KB)] DESC 

Answer 7

In SQL 2008+: Rechtsklick auf den DB-Namen in SSMS, wählen Reports, dann Standard Reports, dann Disk Usage by Table.

Answer 8

könnten Sie verwenden:

SELECT @@servername; 

IF EXISTS(SELECT name FROM tempdb.sys.tables WHERE name LIKE '#spaceUsed%') 
    BEGIN 
     DROP TABLE #spaceUsed; 
    END; 
CREATE TABLE #spaceUsed (
name VARCHAR(255) , 
rows INT , 
reserved VARCHAR(50) , 
data VARCHAR(50) , 
index_size VARCHAR(50) , 
unused VARCHAR(50)); 

EXEC sp_msforeachtable 
@command1 =' 
-- 
INSERT INTO #spaceUsed 
exec sp_spaceused N''?''; 
' 
,@whereand = ' And Object_id In (Select Object_id From sys.objects 
Where SCHEMA_NAME(Schema_ID) like ''%'')'; 

DECLARE 
    @spaceUsedData TABLE (
    name VARCHAR(255) , 
    rows INT , 
    reservedMB BIGINT NULL , 
    dataMB BIGINT NULL , 
    index_sizeMB BIGINT NULL , 
    unusedMB BIGINT NULL); 

INSERT INTO INTO @spaceUsedData (name , rows , reservedMB , dataMB ,index_sizeMB ,unusedMB) 
SELECT     name , rows , 
Convert (BIGINT ,Ltrim(Rtrim(Replace(reserved ,'KB' ,''))))/1024 , 
Convert (BIGINT ,Ltrim(Rtrim(Replace(data ,'KB' ,''))))/1024 , 
Convert (BIGINT ,Ltrim(Rtrim(Replace(index_size ,'KB' ,''))))/1024 , 
Convert (BIGINT ,Ltrim(Rtrim(Replace(unused ,'KB' ,''))))/1024 
FROM #spaceUsed; 

SELECT * , reservedMB+ dataMB+index_sizeMB+unusedMB AS TotalMB FROM @spaceUsedData 
ORDER BY rows DESC;