Para que serve

O DBCC é um comando do servidor SQL que verifica a integridade do banco de dados com a possibilidade de correção ou não.

Muitas vezes quando ocorre um erro de integridade no sql server ele continua funcionando 'aparentemente perfeitamente' porque o erro não é muitas vezes percebido nem pelo próprio SQL e se for percebido ele anota o erro no sistema para que o administrador tome providências mas o serviço SQL Server continua funcionando, muitas vezes, sem que ninguém perceba. Contudo quanto mais tempo demorarmos para corrigir o erro menor a chance de recuperar do erro.

No SQL muitas das funcionalidades são feitas umas apontando para outras. Por exemplo, as páginas de dados são apontadas inicialmente pela definição da tabela e depois cada página aponta para sua antecessora e a sua sucessora. O erro ocorre quando por uma falha esse 'apontamento' está errado, ou seja, por exemplo, a página apontada ( cluster do disco ) sequer é uma página de dados SQL.

A manutenção que este comando pode dar é pequena e só serve para pequenos erros de disco.

Ele gera um arquivo de LOG com as mensagens sobre as verificações efetuadas. Portanto ao final de um DBCC o analista precisará procurar pelas mensagens de erro no seu final e, em caso de erro, tomar as devidas providências para seu conserto.

Note que quando um banco de dados estiver corrompido a última coisa que o sql server fará é deixar a tabela indisponível.
Portanto nem sempre uma tabela DISPONÍVEL é obrigatóriamente uma tabela ÍNTEGRA, perfeita.

Ele consegue verificar a estrutura dos arquivos, procurar erros ou inconsistências na estrutura do servidor SQL. Caso o erro seja relativamente pequeno ele pode corrigir o erro e salvar muito trabalho seu. Senão, provavelmente, você terá que recorrer ao restore de um backup.

Pontos a observar

Como ele verifica a estrutura dos dados do servidor SQL ele é pesado e exige que seja executado em horários de pouca ou nenhuma alteração no banco de dados porque qualquer alteração ele precisaria reiniciar o processo de verificação.
Portanto, ele sempre causa um grande impacto na performance e por esse motivo deve ser feito ou off-line ou em horários mais tranquilos.
Nas versões anteriores do SQL Server - DBCC significava "Database Consistency Checker", agora tem outros nomes mas as mesmas funcionalidades se é que novas não foram incorporadas a ele.

Os DBCCs que você deve conhecer

Verificando todos os bancos de dados da instância

--exec isp_CheckServerForCorruption
Create Procedure isp_CheckServerForCorruption
AS
Begin
    Declare @DBName sysname,@Message varchar(255)
    Declare curDatabases cursor

    for select [name] from master..sysdatabases
    Open curDatabases
    fetch next from curDatabases into @DBName

    While @@FETCH_STATUS = 0 Begin
        Set @Message = '*****BEGIN Processing ' + @DBNAME + '********'
        print @Message
        declare @SQL varchar(255)
        Set @SQL = 'DBCC CHECKDB(' + @DBName + ') with PHYSICAL_ONLY'
        EXEC (@SQL)
        Set @Message = '*****END Processing ' + @DBNAME + '********'
        print @Message
        fetch next from curDatabases into @DBName
    End
    Close curDatabases
    Deallocate curDatabases
End

Compactando um banco de dados

Sabemos que o SQL Server pode expandir os bancos de dados caso seja necessário e haja espaço em disco.
Contudo quando ele comprime o espaço ocupado quando um grande número de dados é eliminado de um banco de dados ?
Resposta: Nunca. O SQL Server NUNCA comprime o banco de dados e o motivo é simples, é um processo muito pesado e quando é executado deixa a tabela fora do ar, com acesso restrito a leitura no máximo.

Existe até uma opção de auto-shrink ( auto - compactação ) da tabela ou banco de dados mas não é ativada porque é muito pesada, carrega demais as tarefas de manutenção do servidor.

    USE Banco_Dados
    GO

    DBCC SHRINKFILE(Banco_Dados_log, 1)
    BACKUP LOG Banco_Dados WITH TRUNCATE_ONLY
    DBCC SHRINKFILE(Banco_Dados_log, 1)
    GO

Reparando banco de dados admitindo possível perda de dados

Nas opções de reparo de banco de dados temos 2 opções : Uma sem perda de dados e outra com possível perda de dados. Primeiro a gente tenta a sem perda de dados e se não conseguir corrigir o problema a gente parte para a segunda solução : com perda de dados.

Eu mesmo já restaurei tabelas corrompidas dando um select para obter os dados até um certo ponto ( que é até o ponto que a tabela estava corrompida ) e dei um outro select com a opção 'DESC' para pegar do fim ao inicio ( que seria o ponto de corrupção da tabela). Com isto consegui recuperar todos os dados de uma tabela corrompida.

    ALTER DATABASE Banco_Dados
    SET single_user WITH ROLLBACK IMMEDIATE;
    go
    
    DBCC checkdb ('Banco_Dados', repair_allow_data_loss);
    go

Reparando banco de dados

Neste caso estaremos reparando o banco de dados sem perda de dados. Se for possível o DBCC fará isso.

    --RECONSTROI_BASE
    exec sp_detach_db INFO_FATURAMENTO
    exec sp_resetstatus INFO_FATURAMENTO
    DBCC DBRECOVER (INFO_FATURAMENTO, ignoreerrors)
    EXEC sp_configure 'allow updates', 1
    RECONFIGURE WITH OVERRIDE
    GO

    BEGIN TRANSACTION
        UPDATE sysdatabases SET status = 32768 WHERE name=' INFO_FATURAMENTO'
    COMMIT TRANSACTION
    GO

    EXEC sp_configure 'allow updates', 1
    RECONFIGURE WITH OVERRIDE
    GO

    --Reconstroi o log
    DBCC REBUILD_LOG(' TAB_FATURAMENTO','E:\MSSQL\Data\INFO_FATURAMENTO_Log_new.LDF')
    DBCC CHECKDB('INFO_FATURAMENTO')
    EXEC sp_dboption 'INFO_FATURAMENTO','dbo use only', false
    GO

    EXEC sp_dboption 'INFO_FATURAMENTO','single user', true
    GO

    DBCC CHECKDB('INFO_FATURAMENTO', REPAIR_FAST)
    DBCC CHECKDB('INFO_FATURAMENTO', REPAIR_ALLOW_DATA_LOSS)
    EXEC sp_dboption 'INFO_FATURAMENTO','single user', false
    
    --testando recuperação
    use INFO_FATURAMENTO
    select * from TAB_FATURAMENTO

Desframentando os índices das bases de dados-Reconstruindo os indices

Dentro das atividades diárias de manutenção do servidor além do DBCC das bases de dados é recomendado desfragmentar a base de dados para melhorar a performance de acesso aos seus dados.

    --Re-indexes the specified database
    CREATE PROCEDURE usp_DefragDatabase
    -- Não usaremos sysname porque seu tamanho é insuficiente.
    -- sysname possui 128 caracteres e por isso usaremos ele.
    @dbname nvarchar(256)
    AS
    BEGIN
        -- Sempre coloque o nome da base de dados entre colchetes
        DECLARE @quoteddbname nvarchar(256)
        set @quoteddbname = quotename( @dbname )

        EXEC('
        USE '+ @quoteddbname +'
        DECLARE @sTableName sysname
        DECLARE PKMS_Tables CURSOR LOCAL FOR
            select table_name from information_schema.tables
            where table_type = ''base table'' order by 1
        OPEN PKMS_Tables
        FETCH NEXT FROM PKMS_Tables INTO @sTableName

        WHILE @@FETCH_STATUS = 0
        BEGIN
        select @sTablename = quotename(@sTablename, ''[]'')
            EXEC('' DBCC DBREINDEX ( ''+@sTableName+'') WITH NO_INFOMSGS'')
            FETCH NEXT FROM PKMS_Tables INTO @sTableName
        END
        CLOSE PKMS_Tables')
    END
    GO

DBCC - Comandos Não Documentados

O DBCC está em constante evolução e por esse motivo há muitos recursos que ainda não foram documentados. Sendo assim, em caso de necessidade você poderá utilizar os recursos abaixo para resolver os problemas dos bancos de dados.

Lembre-se que os comandos DBCC podem afetar o desempenho do sistema e / ou forçar bloqueios no nível da tabela.
Não há garantia de que esses comandos permanecerão disponíveis ou mesmo que funcionarão em qualquer versão futura do SQL Server porque ainda estão em fase experimental de utilização. Alguns podem continuar, outros desaparecerão para dar lugar a um melhor e alguns desaparecerão porque outro melhor foi colocado em seu lugar.

DBCC activecursors [(spid)]
DBCC addextendedproc (function_name, dll_name)
DBCC addinstance (objectname, instancename)
DBCC adduserobject (name)
DBCC auditevent (eventclass, eventsubclass, success, loginname, rolename, dbusername, loginid)
DBCC autopilot (typeid, dbid, tabid, indid, pages [,flag])
DBCC balancefactor (variance_percent)
DBCC bufcount [(number_of_buffers)]
DBCC buffer ( {'dbname' | dbid} [, objid [, number [, printopt={0|1|2} ] [, dirty | io | kept | rlock | ioerr | hashed ]]])
DBCC bytes ( startaddress, length )
DBCC cachestats
DBCC callfulltext
DBCC checkdbts (dbid, newTimestamp)]
DBCC checkprimaryfile ( {'FileName'} [, opt={0|1|2|3} ])
DBCC cacheprofile [( {actionid} [, bucketid])
DBCC clearspacecaches ('database_name'|database_id, 'table_name'|table_id, 'index_name'|index_id)
DBCC collectstats (on | off)
DBCC config
DBCC cursorstats ([spid [,'clear']])
DBCC dbinfo [('dbname')]
DBCC dbrecover (dbname [, IgnoreErrors])
DBCC dbreindexall (db_name/db_id, type_bitmap)
DBCC dbrepair ('dbname', DROPDB [, NOINIT])
DBCC dbtable [({'dbname' | dbid})]
DBCC debugbreak
DBCC deleteinstance (objectname, instancename)
DBCC des [( {'dbname' | dbid} [, {'objname' | objid} ])]
DBCC detachdb [( 'dbname' )]
DBCC dropextendedproc (function_name)
DBCC dropuserobject ('object_name')
DBCC dumptrigger ({'BREAK', {0 | 1}} | 'DISPLAY' | {'SET', exception_number} | {'CLEAR', exception_number})
DBCC errorlog
DBCC extentinfo [({'database_name'| dbid | 0} [,{'table_name' | table_id} [, {'index_name' | index_id | -1}]])]
DBCC fileheader [( {'dbname' | dbid} [, fileid])
DBCC fixallocation [({'ADD' | 'REMOVE'}, {'PAGE' | 'SINGLEPAGE' | 'EXTENT' | 'MIXEDEXTENT'} , filenum, pagenum [, objectid, indid])
DBCC flush ('data' | 'log', dbid)
DBCC flushprocindb (database)
DBCC freeze_io (db)
DBCC getvalue (name)
DBCC icecapquery ('dbname', stored_proc_name [, #_times_to_icecap (-1 infinite, 0 turns off)])

Use 'dbcc icecapquery (printlist)' to see list of SP's to profile.
Use 'dbcc icecapquery (icecapall)' to profile all SP's.

DBCC incrementinstance (objectname, countername, instancename, value)
DBCC ind ( { 'dbname' | dbid }, { 'objname' | objid }, { indid | 0 | -1 | -2 } )
DBCC invalidate_textptr (textptr)
DBCC invalidate_textptr_objid (objid)
DBCC iotrace ( { 'dbname' | dbid | 0 | -1 } , { fileid | 0 }, bufsize, [ { numIOs | -1 } [, { timeout (sec) | -1 } [, printopt={ 0 | 1 }]]] )
DBCC latch ( address [, 'owners'] [, 'stackdumps'])
DBCC lock ([{'DUMPTABLE' | 'DUMPSTATS' | 'RESETSTATS' | 'HASH'}] | [{'STALLREPORTTHESHOLD', stallthreshold}])
DBCC lockobjectschema ('object_name')
DBCC log ([dbid[,{0|1|2|3|4}[,['lsn','[0x]x:y:z']|['numrecs',num]|['xdesid','x:y'] | ['extent','x:y']|['pageid','x:y']|['objid',{x,'y'}]|['logrecs', {'lop'|op}...]|['output',x,['filename','x']]...]]])
DBCC loginfo [({'database_name' | dbid})]
DBCC matview ({'PERSIST' | 'ENDPERSIST' | 'FREE' | 'USE' | 'ENDUSE'})
DBCC memobjlist [(memory object)]
DBCC memorymap
DBCC memorystatus
DBCC memospy
DBCC memusage ([IDS | NAMES], [Number of rows to output])
DBCC monitorevents ('sink' [, 'filter-expression'])
DBCC newalloc - please use checkalloc instead
DBCC no_textptr (table_id , max_inline)
DBCC page ( {'dbname' | dbid}, filenum, pagenum [, printopt={0|1|2|3} ][, cache={0|1} ])
DBCC perflog
DBCC perfmon
DBCC pglinkage (dbid, startfile, startpg, number, printopt={0|1|2} , targetfile, targetpg, order={1|0})
DBCC procbuf [({'dbname' | dbid}[, {'objname' | objid} [, nbufs[, printopt = { 0 | 1 } ]]] )]
DBCC prtipage (dbid, objid, indexid [, [{{level, 0} | {filenum, pagenum}}] [,printopt]])
DBCC pss [(uid[, spid[, printopt = { 1 | 0 }]] )]
DBCC readpage ({ dbid, 'dbname' }, fileid, pageid , formatstr [, printopt = { 0 | 1} ])
DBCC rebuild_log (dbname [, filename])
DBCC renamecolumn (object_name, old_name, new_name)
DBCC resource
DBCC row_lock (dbid, tableid, set) - Not Needed
DBCC ruleoff ({ rulenum | rulestring } [, { rulenum | rulestring } ]+)
DBCC ruleon ( rulenum | rulestring } [, { rulenum | rulestring } ]+)
DBCC setcpuweight (weight)
DBCC setinstance (objectname, countername, instancename, value)
DBCC setioweight (weight)
DBCC showdbaffinity
DBCC showfilestats [(file_num)]
DBCC showoffrules
DBCC showonrules
DBCC showtableaffinity (table)
DBCC showtext ('dbname', {textpointer | {fileid, pageid, slotid[,option]}})
DBCC showweights
DBCC sqlmgrstats
DBCC stackdump [( {uid[, spid[, ecid]} | {threadId, 'THREADID'}] )]
DBCC tab ( dbid, objid )
DBCC tape_control {'query' | 'release'}[,('\\.\tape')]
DBCC tec [( uid[, spid[, ecid]] )]
DBCC textall [({'database_name'|database_id}[, 'FULL' | FAST] )]
DBCC textalloc ({'table_name'|table_id}[, 'FULL' | FAST])
DBCC thaw_io (db)
DBCC upgradedb (db)
DBCC usagegovernor (command, value)
DBCC useplan [(number_of_plan)]
DBCC wakeup (spid)
DBCC writepage ({ dbid, 'dbname' }, fileid, pageid, offset, length, data)