Qual é o equivalente a 'descrever tabela' no SQL Server?

321

Eu tenho um banco de dados do SQL Server e quero saber quais colunas e tipos ele possui. Eu preferiria fazer isso por meio de uma consulta, em vez de usar uma GUI como o Enterprise Manager. Existe uma maneira de fazer isso?

marc_s
fonte
1
Outro stackoverflow [pergunta] [1] respondeu isto [1]: stackoverflow.com/questions/11078106/…
Shiva
Não entendo por que a Microsoft não colocou essa opção de antemão. Isso é necessário ter funcionalidade.
Sukumaar 28/11/19

Respostas:

342

Você pode usar o procedimento armazenado sp_columns :

exec sp_columns MyTable
Vincent Ramdhanie
fonte
1
Obrigado - eu estava prestes a postar a mesma pergunta com T-SQL em vez de MSSQL.
Jedidja
11
Apenas uma observação rápida: não coloque o nome da tabela entre aspas e não use a sintaxe TableOwner.TableName.
Gezim
1
Veja aqui se você não está obtendo resultados ao executar esta consulta.
mlissner
12
use Select * From INFORMATION_SCHEMA.COLUMNS Where TABLE_NAME = 'TABLENAME' se você não quiser usar um procedimento armazenado
Matias Elorriaga
1
A saída de sp_columns é absurdamente ilegível no sqlcmd, mesmo usando enormes larguras de terminal. As soluções utilizadas selectabaixo são muito mais apropriadas para usuários do sqlcmd.
Ctpenrose 15/08
123

Existem alguns métodos para obter metadados sobre uma tabela:

EXEC sp_help tablename

Retornará vários conjuntos de resultados, descrevendo a tabela, suas colunas e restrições.

As INFORMATION_SCHEMAvisualizações fornecerão as informações que você deseja, embora, infelizmente, você precise consultá-las e juntá-las manualmente.

Brannon
fonte
7
Para mim, funcionou sem o caractere "@" EXEC sp_help 'table_name'
Ali
esta é uma versão mais correta da resposta de Viranja. A @sintaxe está incorreta no entanto.
pcnate
Parece que @tablenameé uma variável no exemplo. O sp funciona nos dois sentidos, com uma string ou o tablename 'simples' ( exec sp_help Employeesou exec sp_help 'Employees')
KekuSemau
FYI: O esquema (e até mesmo o banco de dados) podem estar dentro dos limites:execute sp_help 'db.sch.your_table
ColinMac 12/12/18
53

Caso você não queira usar o proc armazenado, aqui está uma versão de consulta simples

select * 
  from information_schema.columns 
 where table_name = 'aspnet_Membership'
 order by ordinal_position
Salamander2007
fonte
1
No meu caso, isso também se aplica se, por algum motivo, esses procs armazenados não estiverem disponíveis.
James Mills
O proc armazenado é inflexível e realmente hostil aos usuários sqlcmd ingênuos como eu
ctpenrose
amo este como ele ordena pelo nome: D
Marin
33

Você pode usar o seguinte

sp_help tablename

Exemplo: sp_help Customer

OU Use atalho

  • selecionar tabela, pressione Alt + F1

Exemplo: Cliente Pressione Alt + F1

Viranja kaushalya
fonte
Observe que, se você tiver a tabela em um esquema definido pelo usuário, deverá excluí-la da consulta. Todo o esquema que contém uma tabela com esse nome aparecerá em uma coluna chamada "TABLE_OWNER" no conjunto de resultados.
Buggieboy #
Observe que, para o atalho funcionar, a tabela / exibição / procedimento deve ser totalmente selecionada. O SSMS não expande automaticamente a seleção (eu esperava isso). Ctrl+Wpode ser usado para expandir a seleção e selecionar o nome inteiro.
bugybunny
29

Use esta consulta

Select * From INFORMATION_SCHEMA.COLUMNS Where TABLE_NAME = 'TABLENAME'
sukhi
fonte
1
Funciona para mim se você disser "use MyDatabase" primeiro.
Jason D
I como este, porque ele funciona em MySQL também, então eu não tenho que mudar meu SQL no meu código
Abdul
1
Esta resposta não é diferente de stackoverflow.com/a/319424/695671, que veio cinco anos antes. Não acho úteis respostas repetidas.
Jason S
15

Além das maneiras mostradas em outras respostas, você pode usar

SELECT TOP 0 * FROM table_name

Isso fornecerá o nome de cada coluna sem resultados e será concluído quase instantaneamente com o mínimo de sobrecarga.

kingfrito_5005
fonte
O TOP 1 também forneceria dados de amostra, que podem ser mais ilustrativos.
Spurgeon
14

Por favor, use a seguinte consulta sql; isso funcionou para o meu caso.

select * FROM   INFORMATION_SCHEMA.Columns where table_name = 'tablename';
Abhijeet
fonte
2
A mesma resposta foi dada em 2008 e 2014. Não acho úteis respostas repetidas.
Jason S
14

Basta selecionar a tabela e pressionar Alt+ F1,

mostrará todas as informações sobre a tabela, como nome da coluna, tipo de dados, chaves etc.

Shwetank Suthar
fonte
7
OP pediu um método GUI-menos
Spikolynn
7

Eu escrevi um sql * mais DESC (RIBE) como select (exibe os comentários da coluna também) no t-sql:

USE YourDB
GO

DECLARE @objectName NVARCHAR(128) = 'YourTable';

SELECT
  a.[NAME]
 ,a.[TYPE]
 ,a.[CHARSET]
 ,a.[COLLATION]
 ,a.[NULLABLE]
 ,a.[DEFAULT]
 ,b.[COMMENTS]
-- ,a.[ORDINAL_POSITION]
FROM
  (
    SELECT
      COLUMN_NAME                                     AS [NAME]
     ,CASE DATA_TYPE
        WHEN 'char'       THEN DATA_TYPE  + '(' + CAST(CHARACTER_MAXIMUM_LENGTH AS VARCHAR) + ')'
        WHEN 'numeric'    THEN DATA_TYPE  + '(' + CAST(NUMERIC_PRECISION AS VARCHAR) + ', ' + CAST(NUMERIC_SCALE AS VARCHAR) + ')'
        WHEN 'nvarchar'   THEN DATA_TYPE  + '(' + CAST(CHARACTER_MAXIMUM_LENGTH AS VARCHAR) + ')'
        WHEN 'varbinary'  THEN DATA_TYPE + '(' + CAST(CHARACTER_MAXIMUM_LENGTH AS VARCHAR) + ')'
        WHEN 'varchar'    THEN DATA_TYPE   + '(' + CAST(CHARACTER_MAXIMUM_LENGTH AS VARCHAR) + ')'
        ELSE DATA_TYPE
      END                                             AS [TYPE]
     ,CHARACTER_SET_NAME                              AS [CHARSET]
     ,COLLATION_NAME                                  AS [COLLATION]
     ,IS_NULLABLE                                     AS [NULLABLE]
     ,COLUMN_DEFAULT                                  AS [DEFAULT]
     ,ORDINAL_POSITION
    FROM   
      INFORMATION_SCHEMA.COLUMNS
    WHERE
      TABLE_NAME = @objectName
  ) a
  FULL JOIN
  (
   SELECT
     CAST(value AS NVARCHAR)                        AS [COMMENTS]
    ,CAST(objname AS NVARCHAR)                      AS [NAME]
   FROM
     ::fn_listextendedproperty ('MS_Description', 'user', 'dbo', 'table', @objectName, 'column', default)
  ) b
  ON a.NAME COLLATE YourCollation = b.NAME COLLATE YourCollation
ORDER BY
  a.[ORDINAL_POSITION];

A seleção acima mencionada pode ser usada em um procedimento armazenado marcado pelo sistema e pode ser chamada de qualquer banco de dados da sua instância de uma maneira simples:

USE master;
GO

IF OBJECT_ID('sp_desc', 'P') IS NOT NULL
  DROP PROCEDURE sp_desc
GO

CREATE PROCEDURE sp_desc (
  @tableName  nvarchar(128)
) AS
BEGIN
  DECLARE @dbName       sysname;
  DECLARE @schemaName   sysname;
  DECLARE @objectName   sysname;
  DECLARE @objectID     int;
  DECLARE @tmpTableName varchar(100);
  DECLARE @sqlCmd       nvarchar(4000);

  SELECT @dbName = PARSENAME(@tableName, 3);
  IF @dbName IS NULL SELECT @dbName = DB_NAME();

  SELECT @schemaName = PARSENAME(@tableName, 2);
  IF @schemaName IS NULL SELECT @schemaName = SCHEMA_NAME();

  SELECT @objectName = PARSENAME(@tableName, 1);
  IF @objectName IS NULL
    BEGIN
      PRINT 'Object is missing from your function call!';
      RETURN;
    END;

  SELECT @objectID = OBJECT_ID(@dbName + '.' + @schemaName + '.' + @objectName);
  IF @objectID IS NULL
    BEGIN
      PRINT 'Object [' + @dbName + '].[' + @schemaName + '].[' + @objectName + '] does not exist!';
      RETURN;
    END;

  SELECT @tmpTableName = '#tmp_DESC_' + CAST(@@SPID AS VARCHAR) + REPLACE(REPLACE(REPLACE(REPLACE(CAST(CONVERT(CHAR, GETDATE(), 121) AS VARCHAR), '-', ''), ' ', ''), ':', ''), '.', '');
  --PRINT @tmpTableName;
  SET @sqlCmd = '
    USE ' + @dbName + '
    CREATE TABLE ' + @tmpTableName + ' (
      [NAME]              nvarchar(128) NOT NULL
     ,[TYPE]              varchar(50)
     ,[CHARSET]           varchar(50)
     ,[COLLATION]         varchar(50)
     ,[NULLABLE]          varchar(3)
     ,[DEFAULT]           nvarchar(4000)
     ,[COMMENTS]          nvarchar(3750));

    INSERT INTO ' + @tmpTableName + '
    SELECT
      a.[NAME]
     ,a.[TYPE]
     ,a.[CHARSET]
     ,a.[COLLATION]
     ,a.[NULLABLE]
     ,a.[DEFAULT]
     ,b.[COMMENTS]
    FROM
      (
        SELECT
          COLUMN_NAME                                     AS [NAME]
         ,CASE DATA_TYPE
            WHEN ''char''      THEN DATA_TYPE + ''('' + CAST(CHARACTER_MAXIMUM_LENGTH AS VARCHAR) + '')''
            WHEN ''numeric''   THEN DATA_TYPE + ''('' + CAST(NUMERIC_PRECISION AS VARCHAR) + '', '' + CAST(NUMERIC_SCALE AS VARCHAR) + '')''
            WHEN ''nvarchar''  THEN DATA_TYPE + ''('' + CAST(CHARACTER_MAXIMUM_LENGTH AS VARCHAR) + '')''
            WHEN ''varbinary'' THEN DATA_TYPE + ''('' + CAST(CHARACTER_MAXIMUM_LENGTH AS VARCHAR) + '')''
            WHEN ''varchar''   THEN DATA_TYPE + ''('' + CAST(CHARACTER_MAXIMUM_LENGTH AS VARCHAR) + '')''
            ELSE DATA_TYPE
          END                                             AS [TYPE]
         ,CHARACTER_SET_NAME                              AS [CHARSET]
         ,COLLATION_NAME                                  AS [COLLATION]
         ,IS_NULLABLE                                     AS [NULLABLE]
         ,COLUMN_DEFAULT                                  AS [DEFAULT]
         ,ORDINAL_POSITION
        FROM   
          INFORMATION_SCHEMA.COLUMNS
        WHERE   
          TABLE_NAME = ''' + @objectName + '''
      ) a
      FULL JOIN
      (
         SELECT
           CAST(value AS NVARCHAR)                        AS [COMMENTS]
          ,CAST(objname AS NVARCHAR)                      AS [NAME]
         FROM
           ::fn_listextendedproperty (''MS_Description'', ''user'', ''' + @schemaName + ''', ''table'', ''' + @objectName + ''', ''column'', default)
      ) b
      ON a.NAME COLLATE Hungarian_CI_AS = b.NAME COLLATE Hungarian_CI_AS
    ORDER BY
      a.[ORDINAL_POSITION];

    SELECT * FROM ' + @tmpTableName + ';'

    --PRINT @sqlCmd;

    EXEC sp_executesql @sqlCmd;
    RETURN;
END;
GO

EXEC sys.sp_MS_marksystemobject sp_desc
GO

Para executar o tipo de procedimento:

EXEC sp_desc 'YourDB.YourSchema.YourTable';

Se você deseja obter uma descrição de um objeto do tipo simples de banco de dados atual (e esquema):

EXEC sp_desc 'YourTable';

Como sp_desc é um procedimento marcado pelo sistema, você também pode deixar o comando exec (também não é recomendado):

sp_desc 'YourTable';
Zsolt Hidasi
fonte
6

O equivalente do SQL Server ao describecomando do Oracle é o procedimento armazenadosp_help

O describecomando fornece informações sobre os nomes, tipos, comprimento, etc. da coluna.

No SQL Server, digamos que você queira descrever uma tabela 'mytable' no esquema 'myschema' no banco de dados 'mydb', faça o seguinte:

USE mydb;
exec sp_help 'myschema.mytable';
VHS
fonte
5

Você pode usar o sp_help 'TableName'

user3819354
fonte
2

O problema com essas respostas é que você está perdendo as informações principais. Embora isso seja um pouco confuso, esta é uma versão rápida que eu criei para garantir que ela contenha as mesmas informações que o MySQL Describe exibe.

Select SC.name AS 'Field', ISC.DATA_TYPE AS 'Type', ISC.CHARACTER_MAXIMUM_LENGTH AS 'Length', SC.IS_NULLABLE AS 'Null', I.is_primary_key AS 'Key', SC.is_identity AS 'Identity'
From sys.columns AS SC 
LEFT JOIN sys.index_columns AS IC
ON IC.object_id = OBJECT_ID('dbo.Expenses') AND 
IC.column_id = SC.column_id
LEFT JOIN sys.indexes AS I 
ON I.object_id = OBJECT_ID('dbo.Expenses') AND 
IC.index_id = I.index_id
LEFT JOIN information_schema.columns ISC
ON ISC.TABLE_NAME = 'Expenses'
AND ISC.COLUMN_NAME = SC.name
WHERE SC.object_id = OBJECT_ID('dbo.Expenses')

fonte
existe alguma razão pela qual is_primary_key nunca teria um valor?
Michael Michael
2

Este é o código que eu uso dentro do EntityFramework Reverse POCO Generator(disponível aqui )

Tabela SQL:

SELECT  c.TABLE_SCHEMA AS SchemaName,
        c.TABLE_NAME AS TableName,
        t.TABLE_TYPE AS TableType,
        c.ORDINAL_POSITION AS Ordinal,
        c.COLUMN_NAME AS ColumnName,
        CAST(CASE WHEN IS_NULLABLE = 'YES' THEN 1
                  ELSE 0
             END AS BIT) AS IsNullable,
        DATA_TYPE AS TypeName,
        ISNULL(CHARACTER_MAXIMUM_LENGTH, 0) AS [MaxLength],
        CAST(ISNULL(NUMERIC_PRECISION, 0) AS INT) AS [Precision],
        ISNULL(COLUMN_DEFAULT, '') AS [Default],
        CAST(ISNULL(DATETIME_PRECISION, 0) AS INT) AS DateTimePrecision,
        ISNULL(NUMERIC_SCALE, 0) AS Scale,
        CAST(COLUMNPROPERTY(OBJECT_ID(QUOTENAME(c.TABLE_SCHEMA) + '.' + QUOTENAME(c.TABLE_NAME)), c.COLUMN_NAME, 'IsIdentity') AS BIT) AS IsIdentity,
        CAST(CASE WHEN COLUMNPROPERTY(OBJECT_ID(QUOTENAME(c.TABLE_SCHEMA) + '.' + QUOTENAME(c.TABLE_NAME)), c.COLUMN_NAME, 'IsIdentity') = 1 THEN 1
                  WHEN COLUMNPROPERTY(OBJECT_ID(QUOTENAME(c.TABLE_SCHEMA) + '.' + QUOTENAME(c.TABLE_NAME)), c.COLUMN_NAME, 'IsComputed') = 1 THEN 1
                  WHEN DATA_TYPE = 'TIMESTAMP' THEN 1
                  ELSE 0
             END AS BIT) AS IsStoreGenerated,
        CAST(CASE WHEN pk.ORDINAL_POSITION IS NULL THEN 0
                  ELSE 1
             END AS BIT) AS PrimaryKey,
        ISNULL(pk.ORDINAL_POSITION, 0) PrimaryKeyOrdinal,
        CAST(CASE WHEN fk.COLUMN_NAME IS NULL THEN 0
                  ELSE 1
             END AS BIT) AS IsForeignKey
FROM    INFORMATION_SCHEMA.COLUMNS c
        LEFT OUTER JOIN (SELECT u.TABLE_SCHEMA,
                                u.TABLE_NAME,
                                u.COLUMN_NAME,
                                u.ORDINAL_POSITION
                         FROM   INFORMATION_SCHEMA.KEY_COLUMN_USAGE u
                                INNER JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc
                                    ON u.TABLE_SCHEMA = tc.CONSTRAINT_SCHEMA
                                       AND u.TABLE_NAME = tc.TABLE_NAME
                                       AND u.CONSTRAINT_NAME = tc.CONSTRAINT_NAME
                         WHERE  CONSTRAINT_TYPE = 'PRIMARY KEY') pk
            ON c.TABLE_SCHEMA = pk.TABLE_SCHEMA
               AND c.TABLE_NAME = pk.TABLE_NAME
               AND c.COLUMN_NAME = pk.COLUMN_NAME
        LEFT OUTER JOIN (SELECT DISTINCT
                                u.TABLE_SCHEMA,
                                u.TABLE_NAME,
                                u.COLUMN_NAME
                         FROM   INFORMATION_SCHEMA.KEY_COLUMN_USAGE u
                                INNER JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc
                                    ON u.TABLE_SCHEMA = tc.CONSTRAINT_SCHEMA
                                       AND u.TABLE_NAME = tc.TABLE_NAME
                                       AND u.CONSTRAINT_NAME = tc.CONSTRAINT_NAME
                         WHERE  CONSTRAINT_TYPE = 'FOREIGN KEY') fk
            ON c.TABLE_SCHEMA = fk.TABLE_SCHEMA
               AND c.TABLE_NAME = fk.TABLE_NAME
               AND c.COLUMN_NAME = fk.COLUMN_NAME
        INNER JOIN INFORMATION_SCHEMA.TABLES t
            ON c.TABLE_SCHEMA = t.TABLE_SCHEMA
               AND c.TABLE_NAME = t.TABLE_NAME
WHERE c.TABLE_NAME NOT IN ('EdmMetadata', '__MigrationHistory')

Chave estrangeira SQL:

SELECT  FK.name AS FK_Table,
        FkCol.name AS FK_Column,
        PK.name AS PK_Table,
        PkCol.name AS PK_Column,
        OBJECT_NAME(f.object_id) AS Constraint_Name,
        SCHEMA_NAME(FK.schema_id) AS fkSchema,
        SCHEMA_NAME(PK.schema_id) AS pkSchema,
        PkCol.name AS primarykey,
        k.constraint_column_id AS ORDINAL_POSITION
FROM    sys.objects AS PK
        INNER JOIN sys.foreign_keys AS f
            INNER JOIN sys.foreign_key_columns AS k
                ON k.constraint_object_id = f.object_id
            INNER JOIN sys.indexes AS i
                ON f.referenced_object_id = i.object_id
                   AND f.key_index_id = i.index_id
            ON PK.object_id = f.referenced_object_id
        INNER JOIN sys.objects AS FK
            ON f.parent_object_id = FK.object_id
        INNER JOIN sys.columns AS PkCol
            ON f.referenced_object_id = PkCol.object_id
               AND k.referenced_column_id = PkCol.column_id
        INNER JOIN sys.columns AS FkCol
            ON f.parent_object_id = FkCol.object_id
               AND k.parent_column_id = FkCol.column_id
ORDER BY FK_Table, FK_Column

Propriedades estendidas:

SELECT  s.name AS [schema],
        t.name AS [table],
        c.name AS [column],
        value AS [property]
FROM    sys.extended_properties AS ep
        INNER JOIN sys.tables AS t
            ON ep.major_id = t.object_id
        INNER JOIN sys.schemas AS s
            ON s.schema_id = t.schema_id
        INNER JOIN sys.columns AS c
            ON ep.major_id = c.object_id
               AND ep.minor_id = c.column_id
WHERE   class = 1
ORDER BY t.name
Simon Hughes
fonte
1

usar

SELECT COL_LENGTH('tablename', 'colname')

Nenhuma outra solução funcionou para mim.

Pravin
fonte
isso requer saber quais são as outras colunas. Também há um erro de digitação
pcnate
Corrigida a cotação.
Nikeee 26/10
1

Eu gosto deste formato:

name     DataType      Collation             Constraints         PK  FK          Comment

id       int                                 NOT NULL IDENTITY   PK              Order Line Id
pid      int                                 NOT NULL                tbl_orders  Order Id
itemCode varchar(10)   Latin1_General_CI_AS  NOT NULL                            Product Code

Então, eu usei isso:

DECLARE @tname varchar(100) = 'yourTableName';

SELECT  col.name,

        CASE typ.name
            WHEN 'nvarchar' THEN 'nvarchar('+CAST((col.max_length / 2) as varchar)+')'
            WHEN 'varchar' THEN 'varchar('+CAST(col.max_length as varchar)+')'
            WHEN 'char' THEN 'char('+CAST(col.max_length as varchar)+')'
            WHEN 'nchar' THEN 'nchar('+CAST((col.max_length / 2) as varchar)+')'
            WHEN 'binary' THEN 'binary('+CAST(col.max_length as varchar)+')'
            WHEN 'varbinary' THEN 'varbinary('+CAST(col.max_length as varchar)+')'
            WHEN 'numeric' THEN 'numeric('+CAST(col.precision as varchar)+(CASE WHEN col.scale = 0 THEN '' ELSE ','+CAST(col.scale as varchar) END) +')'
            WHEN 'decimal' THEN 'decimal('+CAST(col.precision as varchar)+(CASE WHEN col.scale = 0 THEN '' ELSE ','+CAST(col.scale as varchar) END) +')'
            ELSE typ.name
            END DataType,

        ISNULL(col.collation_name,'') Collation,

        CASE WHEN col.is_nullable = 0 THEN 'NOT NULL ' ELSE '' END + CASE WHEN col.is_identity = 1 THEN 'IDENTITY' ELSE '' END Constraints,

        ISNULL((SELECT 'PK'
                FROM    sys.key_constraints kc INNER JOIN
                        sys.tables tb ON tb.object_id = kc.parent_object_id INNER JOIN
                        sys.indexes si ON si.name = kc.name INNER JOIN
                        sys.index_columns sic ON sic.index_id = si.index_id AND sic.object_id = si.object_id
                WHERE kc.type = 'PK'
                  AND tb.name = @tname
                  AND sic.column_id = col.column_id),'') PK,

        ISNULL((SELECT (SELECT name FROM sys.tables st WHERE st.object_id = fkc.referenced_object_id)
                FROM    sys.foreign_key_columns fkc INNER JOIN
                        sys.columns c ON c.column_id = fkc.parent_column_id AND fkc.parent_object_id = c.object_id INNER JOIN
                        sys.tables t ON t.object_id = c.object_id
                WHERE t.name = tab.name
                  AND c.name = col.name),'') FK,

        ISNULL((SELECT value
                FROM sys.extended_properties
                WHERE major_id = tab.object_id
                  AND minor_id = col.column_id),'') Comment

FROM sys.columns col INNER JOIN
     sys.tables tab ON tab.object_id = col.object_id INNER JOIN
     sys.types typ ON typ.system_type_id = col.system_type_id
WHERE tab.name = @tname
  AND typ.name != 'sysname'
ORDER BY col.column_id;
Graham
fonte
1
SELECT C.COLUMN_NAME, C.IS_NULLABLE, C.DATA_TYPE, TC.CONSTRAINT_TYPE, C.COLUMN_DEFAULT
    FROM INFORMATION_SCHEMA.COLUMNS AS C
    FULL JOIN INFORMATION_SCHEMA.CONSTRAINT_COLUMN_USAGE AS CC ON C.COLUMN_NAME = CC.COLUMN_NAME 
    FULL JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS AS TC ON CC.CONSTRAINT_NAME = TC.CONSTRAINT_NAME
WHERE C.TABLE_NAME = '<Table Name>';

Saída de amostra

abhishek khanna
fonte
Bem-vindo ao SO! Ao responder a uma pergunta, tente explicar um pouco sua resposta. No seu caso, há mais 16 respostas assim que você deve expor os prós e contras de sua resposta
David García Bodego
1

Se você estiver usando o FirstResponderKit da equipe Brent Ozar, também poderá executar esta consulta:

exec sp_blitzindex @tablename='MyTable'

Ele retornará todas as informações sobre a tabela:

  • índices com suas estatísticas de uso (leituras, gravações, bloqueios, etc.), espaço usado e outros
  • índices ausentes
  • colunas
  • chaves estrangeiras
  • conteúdo estatístico Amostra sp_BlitzIndex

É claro que não é um sistema e nem um stp tão universal como sp_help ou sp_columns , mas retorna todas as informações possíveis sobre a sua tabela e acho que vale a pena criá-la no seu ambiente e mencioná-la aqui.

Dmitriy Grishin - dogrishin
fonte
1

Basta clicar duas vezes no nome da tabela e pressionar Alt + F1

homem
fonte
0
CREATE PROCEDURE [dbo].[describe] 
( 
@SearchStr nvarchar(max) 
) 
AS 
BEGIN 
SELECT  
    CONCAT([COLUMN_NAME],' ',[DATA_TYPE],' ',[CHARACTER_MAXIMUM_LENGTH],' ', 
    (SELECT CASE [IS_NULLABLE] WHEN 'NO' THEN 'NOT NULL' ELSE 'NULL' END),
    (SELECT CASE WHEN [COLUMN_DEFAULT] IS NULL THEN '' ELSE CONCAT(' DEFAULT ',[COLUMN_DEFAULT]) END)
    ) AS DESCRIPTION
    FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME LIKE @SearchStr
END 
Brian Somerfield
fonte