AskOverflow.Dev

AskOverflow.Dev Logo AskOverflow.Dev Logo

AskOverflow.Dev Navigation

  • Início
  • system&network
  • Ubuntu
  • Unix
  • DBA
  • Computer
  • Coding
  • LangChain

Mobile menu

Close
  • Início
  • system&network
    • Recentes
    • Highest score
    • tags
  • Ubuntu
    • Recentes
    • Highest score
    • tags
  • Unix
    • Recentes
    • tags
  • DBA
    • Recentes
    • tags
  • Computer
    • Recentes
    • tags
  • Coding
    • Recentes
    • tags
Início / dba / 问题

All perguntas(dba)

Martin Hope
Hannah Vernon
Asked: 2018-05-04 12:55:40 +0800 CST

CREATE DATABASE em partições RAW não funciona mais?

  • 16

Estou tentando criar um banco de dados usando duas partições brutas, ou seja, não formatadas.

O Microsoft Docs afirma que você pode fazer isso, basta especificar apenas a letra da unidade da partição bruta, como em:

CREATE DATABASE DirectDevice 
ON (NAME = DirectDevice_system, FILENAME = 'S:')
LOG ON (NAME = DirectDevice_log, FILENAME = 'T:')

No entanto, o SQL Server 2017 retorna este erro:

Msg 5170, Level 16, State 4, Line 1
Não é possível criar o arquivo 'S:' porque ele já existe. Altere o caminho do arquivo ou o nome do arquivo e repita a operação.
Msg 1802, Level 16, State 4, Line 1
CREATE DATABASE falhou. Alguns nomes de arquivo listados não puderam ser criados. Verifique os erros relacionados.

A parte pertinente da documentação afirma:

Se o arquivo estiver em uma partição bruta, os_file_name deverá especificar apenas a letra da unidade de uma partição bruta existente. Apenas um arquivo de dados pode ser criado em cada partição bruta.

E sim, a unidade S: e T: são partições brutas não formatadas que existem no meu sistema:

DISKPART> partição de detalhes

Partição 4
Tipo: ebd0a0a2-b9e5-4433-87c0-68b6b72699c7
Oculto: Não
Obrigatório: Não
Atributo: 0000000000000000
Deslocamento em Bytes: 999934656512

  Volume ### Ltr Label Fs Tipo Tamanho Informações de Status
  ---------- --- ----------- ----- ---------- ------- ---- ----- --------
* Volume 6 T RAW Partição 127 MB Saudável

DISKPART> selecione a partição 3

A partição 3 agora é a partição selecionada.

DISKPART> partição de detalhes

Partição 3
Tipo: ebd0a0a2-b9e5-4433-87c0-68b6b72699c7
Oculto: Não
Obrigatório: Não
Atributo: 0000000000000000
Deslocamento em Bytes: 1000067825664

  Volume ### Ltr Label Fs Tipo Tamanho Informações de Status
  ---------- --- ----------- ----- ---------- ------- ---- ----- --------
* Volume 7 S RAW Partição 129 MB Saudável

Remover os dois pontos das letras da unidade, como em FILENAME = 'S'e FILENAME = 'T', resulta em:

Msg 5105, Level 16, State 2, Line 1
Ocorreu um erro de ativação de arquivo. O nome do arquivo físico 'S' pode estar incorreto. Diagnostique e corrija erros adicionais e repita a operação.
Msg 1802, Level 16, State 1, Line 1
CREATE DATABASE falhou. Alguns nomes de arquivo listados não puderam ser criados. Verifique os erros relacionados.

A documentação do SQL Server 2000 mostra o seguinte exemplo na CREATE DATABASEseção:

H. Use partições brutas
Este exemplo cria um banco de dados chamado Employees usando partições brutas. As partições brutas devem existir quando a instrução for executada e apenas um arquivo pode ir em cada partição bruta.

    USE master
    GO
    CREATE DATABASE Employees
    ON
    ( NAME = Empl_dat,
        FILENAME = 'f:',
        SIZE = 10,
        MAXSIZE = 50,
        FILEGROWTH = 5 )
    LOG ON
    ( NAME = 'Sales_log',
        FILENAME = 'g:',
        SIZE = 5MB,
        MAXSIZE = 25MB,
        FILEGROWTH = 5MB )
    GO

No entanto, o exemplo acima mostra SIZE, MAXSIZEe FILEGROWTHparâmetros que claramente não são necessários para arquivos de dados do SQL Server armazenados em partições RAW.

Mais detalhes da documentação do SQL Server 2000, especificamente sobre unidades brutas:

Usando partições brutas
O Microsoft® SQL Server™ 2000 suporta o uso de partições brutas para criar arquivos de banco de dados. Partições brutas são partições de disco que não foram formatadas com um sistema de arquivos Microsoft Windows NT®, como FAT e NTFS. Em alguns casos, o uso de bancos de dados criados em partições brutas pode gerar um pequeno ganho de desempenho em relação ao NTFS ou FAT. No entanto, para a maioria das instalações, o método preferencial é usar arquivos criados em partições NTFS ou FAT. Ao criar um arquivo de banco de dados em uma partição bruta, você não especifica os nomes físicos dos arquivos que compõem o banco de dados; você especifica apenas as letras de unidade dos discos nos quais os arquivos de banco de dados devem ser criados. Se você estiver usando o Microsoft Windows® 2000 Server, poderá criar unidades montadas para apontar para partições brutas. Quando você monta uma unidade local em uma pasta vazia, O Windows 2000 atribui um caminho de unidade à unidade em vez de uma letra de unidade. As unidades montadas não estão sujeitas ao limite de 26 unidades imposto pelas letras das unidades; portanto, você pode usar um número ilimitado de partições brutas. Ao criar um arquivo de banco de dados em uma unidade montada, você deve encerrar o caminho da unidade para o nome do arquivo com uma barra invertida (), por exemplo, E:\Nome da amostra. Para obter informações sobre como criar uma unidade montada, consulte a documentação do Windows 2000 Server.

Há várias limitações a serem consideradas ao usar partições brutas:
Apenas um arquivo de banco de dados pode ser criado em cada partição bruta. A partição lógica deve ser configurada como um único arquivo de banco de dados, pois não há sistema de arquivos na partição bruta.

As operações padrão do sistema de arquivos, como copiar, mover e excluir, não podem ser usadas com partições brutas.

Arquivos de banco de dados localizados em partições brutas não podem ser copiados usando o utilitário Backup do Windows NT. No entanto, os backups de banco de dados ou log de transações do SQL Server ainda podem ser criados.

Arquivos de banco de dados em partições brutas não podem ser expandidos automaticamente. Crie inicialmente o banco de dados em seu tamanho completo ou expanda manualmente os arquivos do banco de dados. Para obter mais informações, consulte Expandindo um banco de dados.

Somente partições com letras, como E:, ou unidades montadas, como E:\Sample name\ podem ser usadas. Dispositivos numerados não podem ser usados.

Os serviços do sistema de arquivos, como substituição de bloco inválido, não estão disponíveis com partições brutas.


Isso foi inspirado no post de Brent Ozar sobre o SQL Server 6.5 , que suportava partições brutas

sql-server storage
  • 1 respostas
  • 983 Views
Martin Hope
Josh Darnell
Asked: 2018-04-05 11:49:25 +0800 CST

Por que CHECKDB está lendo o arquivo de log de transações em um banco de dados com uma tabela com otimização de memória?

  • 16

tl; dr : por que CHECKDB está lendo o log de transações para um banco de dados de usuário com tabelas otimizadas para memória?


Parece que CHECKDB está lendo o arquivo de log de transações do banco de dados do usuário quando está verificando um dos meus bancos de dados - em particular, um banco de dados que usa tabelas OLTP na memória.

CHECKDB para este banco de dados ainda termina em um período de tempo razoável, então estou apenas curioso sobre o comportamento; mas é definitivamente a duração mais longa para CHECKDB de todos os bancos de dados nesta instância.

Ao examinar o épico " CHECKDB From Every Angle: Complete description of all CHECKDB stage " de Paul Randal ", vejo que o CHECKDB pré-SQL 2005 costumava ler o log para obter uma visão consistente do banco de dados. Mas como é 2016, ele usa um instantâneo de banco de dados interno.

No entanto, um dos pré- requisitos para instantâneos é que:

O banco de dados de origem não deve conter um grupo de arquivos MEMORY_OPTIMIZED_DATA

Meu banco de dados de usuário tem um desses grupos de arquivos, então parece que os instantâneos estão fora da mesa.

De acordo com os documentos CHECKDB :

Se um instantâneo não puder ser criado ou TABLOCK for especificado, DBCC CHECKDB adquirirá bloqueios para obter a consistência necessária. Nesse caso, um bloqueio de banco de dados exclusivo é necessário para realizar as verificações de alocação e os bloqueios de tabela compartilhada são necessários para realizar as verificações de tabela.

Ok, então estamos fazendo o bloqueio de banco de dados e tabela em vez de instantâneos. Mas isso ainda não explica por que ele precisa ler o log de transações. Então o que dá?

Forneci um script abaixo para reproduzir o cenário. Ele é usado sys.dm_io_virtual_file_statspara identificar as leituras do arquivo de log.

Observe que na maioria das vezes ele lê uma pequena parte do log (480 KB), mas ocasionalmente lê muito mais (48,2 MB). No meu cenário de produção, ele lê a maior parte do arquivo de log (~1,3 GB do arquivo de 2 GB) todas as noites à meia-noite quando executamos CHECKDB.

Aqui está um exemplo das saídas que obtive até agora com o script:

collection_time            num_of_reads     num_of_bytes_read
2018-04-04 15:12:29.203    106              50545664

Ou isto:

collection_time            num_of_reads     num_of_bytes_read
2018-04-04 15:25:14.227    1                491520

Se eu substituir os objetos com otimização de memória por tabelas regulares, a saída será assim:

collection_time            num_of_reads     num_of_bytes_read
2018-04-04 15:21:03.207    0                0

Por que CHECKDB está lendo o arquivo de log? E especialmente, por que ocasionalmente lê uma parte muito maior do arquivo de log?

Aqui está o script real:

-- let's have a fresh DB
USE [master];

IF (DB_ID(N'LogFileRead_Test') IS NOT NULL) 
BEGIN
    ALTER DATABASE [LogFileRead_Test]
    SET SINGLE_USER WITH ROLLBACK IMMEDIATE;
    DROP DATABASE [LogFileRead_Test];
END

GO
CREATE DATABASE [LogFileRead_Test]

GO
ALTER DATABASE [LogFileRead_Test]
MODIFY FILE
(
    NAME = LogFileRead_Test_log,
    SIZE = 128MB
);

-- Hekaton-yeah, I want memory optimized data
GO
ALTER DATABASE [LogFileRead_Test]
ADD FILEGROUP [LatencyTestInMemoryFileGroup] CONTAINS MEMORY_OPTIMIZED_DATA;

GO
ALTER DATABASE [LogFileRead_Test]
ADD FILE 
(
    NAME = [LatencyTestInMemoryFile], 
    FILENAME = 'C:\Program Files\Microsoft SQL Server\MSSQL13.SQL2016\MSSQL\DATA\LogFileRead_Test_SessionStateInMemoryFile'
) TO FILEGROUP [LatencyTestInMemoryFileGroup];

GO
USE [LogFileRead_Test]

GO
CREATE TYPE [dbo].[InMemoryIdTable] AS TABLE (
    [InMemoryId] NVARCHAR (88) COLLATE Latin1_General_100_BIN2 NOT NULL,
    PRIMARY KEY NONCLUSTERED HASH ([InMemoryId]) WITH (BUCKET_COUNT = 240))
    WITH (MEMORY_OPTIMIZED = ON);

GO
CREATE TABLE [dbo].[InMemoryStuff] (
    [InMemoryId]   NVARCHAR (88)    COLLATE Latin1_General_100_BIN2 NOT NULL,
    [Created]     DATETIME2 (7)    NOT NULL,
    CONSTRAINT [PK_InMemoryStuff_InMemoryId] PRIMARY KEY NONCLUSTERED HASH ([InMemoryId]) WITH (BUCKET_COUNT = 240)
)
WITH (MEMORY_OPTIMIZED = ON);

GO
-- RBAR is the new black (we need some logs to read)
declare @j int = 0;
while @j < 100000
begin
    INSERT INTO [dbo].[InMemoryStuff](InMemoryId, Created) VALUES ('Description' + CAST(@j as varchar), GETDATE());
    set @j = @j + 1;
end

-- grab a baseline of virtual file stats to be diff'd later
select f.num_of_reads, f.num_of_bytes_read
into #dm_io_virtual_file_stats
from sys.dm_io_virtual_file_stats(default, default) f
where database_id = db_id('LogFileRead_Test') and file_id = FILE_IDEX('LogFileRead_Test_log');

-- hands off my log file, CHECKDB!
GO
DBCC CHECKDB ([LogFileRead_Test]) WITH NO_INFOMSGS, ALL_ERRORMSGS, DATA_PURITY;

-- grab the latest virtual file stats, and compare with the previous capture
GO
select f.num_of_reads, f.num_of_bytes_read
into #checkdb_stats
from sys.dm_io_virtual_file_stats(default, default) f
where database_id = db_id('LogFileRead_Test') and file_id = FILE_IDEX('LogFileRead_Test_log');

select 
        collection_time = GETDATE() 
        , num_of_reads = - f.num_of_reads + t.num_of_reads
        , num_of_bytes_read = - f.num_of_bytes_read + t.num_of_bytes_read
into #dm_io_virtual_file_stats_diff
from #dm_io_virtual_file_stats f, #checkdb_stats t;

drop table #checkdb_stats;
drop table #dm_io_virtual_file_stats;

-- CHECKDB ignored my comment
select collection_time, num_of_reads, num_of_bytes_read
from #dm_io_virtual_file_stats_diff d
order by d.collection_time;

drop table #dm_io_virtual_file_stats_diff;

-- I was *not* raised in a barn
USE [master];

ALTER DATABASE [LogFileRead_Test]
SET SINGLE_USER WITH ROLLBACK IMMEDIATE;
DROP DATABASE [LogFileRead_Test];

Como esse repro geralmente gera apenas 1 ou 106 leituras de arquivos de log, pensei em pesquisar o 1 com uma sessão de eventos estendidos file_read e file_read_completed.

name                timestamp                   mode        offset  database_id file_id size    duration
file_read           2018-04-06 10:51:11.1098141 Contiguous  72704   9           2       0       NULL    
file_read_completed 2018-04-06 10:51:11.1113345 Contiguous  72704   9           2       491520  1       

E aqui estão os detalhes do VLF ( DBCC LOGINFO()) para o contexto desses deslocamentos e tal:

RecoveryUnitId  FileId  FileSize    StartOffset FSeqNo  Status  Parity  CreateLSN
0               2       2031616     8192        34      2       64      0
0               2       2031616     2039808     35      2       64      0
0               2       2031616     4071424     36      2       64      0
0               2       2285568     6103040     37      2       64      0
0               2       15728640    8388608     38      2       64      34000000005200001
0               2       15728640    24117248    39      2       64      34000000005200001
0               2       15728640    39845888    40      2       64      34000000005200001
0               2       15728640    55574528    0       0       0       34000000005200001
0               2       15728640    71303168    0       0       0       34000000005200001
0               2       15728640    87031808    0       0       0       34000000005200001
0               2       15728640    102760448   0       0       0       34000000005200001
0               2       15728640    118489088   0       0       0       34000000005200001

Então, a operação CHECKDB:

  • começou a ler 63 KB (64.512 bytes) no primeiro VLF,
  • leia 480 KB (491.520 bytes) e
  • não leu os últimos 1.441 KB ( 1.475.584 bytes) do VLF

Também capturei as pilhas de chamadas, caso sejam úteis.

pilha de chamadas file_read:

(00007ffd`999a0860)   sqlmin!XeSqlPkg::file_read::Publish+0x1dc   |  (00007ffd`999a0b40)   sqlmin!XeSqlPkg::file_read_enqueued::Publish
(00007ffd`9a825e30)   sqlmin!FireReadEvent+0x118   |  (00007ffd`9a825f60)   sqlmin!FireReadEnqueuedEvent
(00007ffd`9980b500)   sqlmin!FCB::AsyncRead+0x74d   |  (00007ffd`9980b800)   sqlmin!FCB::AsyncReadInternal
(00007ffd`9970e9d0)   sqlmin!SQLServerLogMgr::LogBlockReadAheadAsync+0x6a6   |  (00007ffd`9970ec00)   sqlmin!LBH::Destuff
(00007ffd`9970a6d0)   sqlmin!LogConsumer::GetNextLogBlock+0x1591   |  (00007ffd`9970ab70)   sqlmin!LogPoolPrivateCacheBufferMgr::Lookup
(00007ffd`9a9fcbd0)   sqlmin!SQLServerLogIterForward::GetNext+0x258   |  (00007ffd`9a9fd2d0)   sqlmin!SQLServerLogIterForward::GetNextBlock
(00007ffd`9aa417f0)   sqlmin!SQLServerCOWLogIterForward::GetNext+0x2b   |  (00007ffd`9aa418c0)   sqlmin!SQLServerCOWLogIterForward::StartScan
(00007ffd`9aa64210)   sqlmin!RecoveryMgr::AnalysisPass+0x83b   |  (00007ffd`9aa65100)   sqlmin!RecoveryMgr::AnalyzeLogRecord
(00007ffd`9aa5ed50)   sqlmin!RecoveryMgr::PhysicalRedo+0x233   |  (00007ffd`9aa5f790)   sqlmin!RecoveryMgr::PhysicalCompletion
(00007ffd`9aa7fd90)   sqlmin!RecoveryUnit::PhysicalRecovery+0x358   |  (00007ffd`9aa802c0)   sqlmin!RecoveryUnit::CompletePhysical
(00007ffd`9a538b90)   sqlmin!StartupCoordinator::NotifyPhaseStart+0x3a   |  (00007ffd`9a538bf0)   sqlmin!StartupCoordinator::NotifyPhaseEnd
(00007ffd`9a80c430)   sqlmin!DBTABLE::ReplicaCreateStartup+0x2f4   |  (00007ffd`9a80c820)   sqlmin!DBTABLE::RefreshPostRecovery
(00007ffd`9a7ed0b0)   sqlmin!DBMgr::SyncAndLinkReplicaRecoveryPhase+0x890   |  (00007ffd`9a7edff0)   sqlmin!DBMgr::DetachDB
(00007ffd`9a7f2cd0)   sqlmin!DBMgr::CreatePhasedTransientReplica+0x869   |  (00007ffd`9a7f3630)   sqlmin!DBMgr::StrandTransientReplica
(00007ffd`9a7f2ae0)   sqlmin!DBMgr::CreateTransientReplica+0x118   |  (00007ffd`9a7f2cd0)   sqlmin!DBMgr::CreatePhasedTransientReplica
(00007ffd`99ec6d30)   sqlmin!DBDDLAgent::CreateReplica+0x1b5   |  (00007ffd`99ec6f90)   sqlmin!FSystemDatabase
(00007ffd`9abaaeb0)   sqlmin!UtilDbccCreateReplica+0x82   |  (00007ffd`9abab000)   sqlmin!UtilDbccDestroyReplica
(00007ffd`9ab0d7e0)   sqlmin!UtilDbccCheckDatabase+0x994   |  (00007ffd`9ab0ffd0)   sqlmin!UtilDbccRetainReplica
(00007ffd`9ab0cfc0)   sqlmin!DbccCheckDB+0x22d   |  (00007ffd`9ab0d380)   sqlmin!DbccCheckFilegroup
(00007ffd`777379c0)   sqllang!DbccCommand::Execute+0x193   |  (00007ffd`77737d70)   sqllang!DbccHelp
(00007ffd`777e58d0)   sqllang!CStmtDbcc::XretExecute+0x889   |  (00007ffd`777e6250)   sqllang!UtilDbccSetPermissionFailure
(00007ffd`76b02eb0)   sqllang!CMsqlExecContext::ExecuteStmts<1,1>+0x40d   |  (00007ffd`76b03410)   sqllang!CSQLSource::CleanupCompileXactState
(00007ffd`76b03a60)   sqllang!CMsqlExecContext::FExecute+0xa9e   |  (00007ffd`76b043d0)   sqllang!CCacheObject::Release
(00007ffd`76b03430)   sqllang!CSQLSource::Execute+0x981   |  (00007ffd`76b039b0)   sqllang!CSQLLock::Cleanup

pilha de chamadas file_read_completed:

(00007ffd`99995cc0)   sqlmin!XeSqlPkg::file_read_completed::Publish+0x1fc   |  (00007ffd`99995fe0)   sqlmin!XeSqlPkg::file_write_completed::Publish
(00007ffd`9a826630)   sqlmin!FireIoCompletionEventLong+0x227   |  (00007ffd`9a8269c0)   sqlmin!IoRequestDispenser::Dump
(00007ffd`9969bee0)   sqlmin!FCB::IoCompletion+0x8e   |  (00007ffd`9969c180)   sqlmin!IoRequestDispenser::Put
(00007ffd`beaa11e0)   sqldk!IOQueue::CheckForIOCompletion+0x426   |  (00007ffd`beaa1240)   sqldk!SystemThread::GetCurrentId
(00007ffd`beaa15b0)   sqldk!SOS_Scheduler::SwitchContext+0x173   |  (00007ffd`beaa18a0)   sqldk!SOS_Scheduler::Switch
(00007ffd`beaa1d00)   sqldk!SOS_Scheduler::SuspendNonPreemptive+0xd3   |  (00007ffd`beaa1db0)   sqldk!SOS_Scheduler::ResumeNoCuzz
(00007ffd`99641720)   sqlmin!EventInternal<SuspendQueueSLock>::Wait+0x1e7   |  (00007ffd`99641ae0)   sqlmin!SOS_DispatcherPool<DispatcherWorkItem,DispatcherWorkItem,SOS_DispatcherQueue<DispatcherWorkItem,0,DispatcherWorkItem>,DispatcherPoolConfig,void * __ptr64>::GetDispatchers
(00007ffd`9aa437c0)   sqlmin!SQLServerLogMgr::CheckLogBlockReadComplete+0x1e6   |  (00007ffd`9aa44670)   sqlmin!SQLServerLogMgr::ValidateBlock
(00007ffd`9970a6d0)   sqlmin!LogConsumer::GetNextLogBlock+0x1b37   |  (00007ffd`9970ab70)   sqlmin!LogPoolPrivateCacheBufferMgr::Lookup
(00007ffd`9a9fcbd0)   sqlmin!SQLServerLogIterForward::GetNext+0x258   |  (00007ffd`9a9fd2d0)   sqlmin!SQLServerLogIterForward::GetNextBlock
(00007ffd`9aa417f0)   sqlmin!SQLServerCOWLogIterForward::GetNext+0x2b   |  (00007ffd`9aa418c0)   sqlmin!SQLServerCOWLogIterForward::StartScan
(00007ffd`9aa64210)   sqlmin!RecoveryMgr::AnalysisPass+0x83b   |  (00007ffd`9aa65100)   sqlmin!RecoveryMgr::AnalyzeLogRecord
(00007ffd`9aa5ed50)   sqlmin!RecoveryMgr::PhysicalRedo+0x233   |  (00007ffd`9aa5f790)   sqlmin!RecoveryMgr::PhysicalCompletion
(00007ffd`9aa7fd90)   sqlmin!RecoveryUnit::PhysicalRecovery+0x358   |  (00007ffd`9aa802c0)   sqlmin!RecoveryUnit::CompletePhysical
(00007ffd`9a538b90)   sqlmin!StartupCoordinator::NotifyPhaseStart+0x3a   |  (00007ffd`9a538bf0)   sqlmin!StartupCoordinator::NotifyPhaseEnd
(00007ffd`9a80c430)   sqlmin!DBTABLE::ReplicaCreateStartup+0x2f4   |  (00007ffd`9a80c820)   sqlmin!DBTABLE::RefreshPostRecovery
(00007ffd`9a7ed0b0)   sqlmin!DBMgr::SyncAndLinkReplicaRecoveryPhase+0x890   |  (00007ffd`9a7edff0)   sqlmin!DBMgr::DetachDB
(00007ffd`9a7f2cd0)   sqlmin!DBMgr::CreatePhasedTransientReplica+0x869   |  (00007ffd`9a7f3630)   sqlmin!DBMgr::StrandTransientReplica
(00007ffd`9a7f2ae0)   sqlmin!DBMgr::CreateTransientReplica+0x118   |  (00007ffd`9a7f2cd0)   sqlmin!DBMgr::CreatePhasedTransientReplica
(00007ffd`99ec6d30)   sqlmin!DBDDLAgent::CreateReplica+0x1b5   |  (00007ffd`99ec6f90)   sqlmin!FSystemDatabase
(00007ffd`9abaaeb0)   sqlmin!UtilDbccCreateReplica+0x82   |  (00007ffd`9abab000)   sqlmin!UtilDbccDestroyReplica
(00007ffd`9ab0d7e0)   sqlmin!UtilDbccCheckDatabase+0x994   |  (00007ffd`9ab0ffd0)   sqlmin!UtilDbccRetainReplica
(00007ffd`9ab0cfc0)   sqlmin!DbccCheckDB+0x22d   |  (00007ffd`9ab0d380)   sqlmin!DbccCheckFilegroup
(00007ffd`777379c0)   sqllang!DbccCommand::Execute+0x193   |  (00007ffd`77737d70)   sqllang!DbccHelp

Esses rastreamentos de pilha se correlacionam com a resposta de Max, indicando que CHECKDB está usando um instantâneo interno, apesar da presença das tabelas Hekaton.

Eu li que os instantâneos executam a recuperação para desfazer transações não confirmadas :

As transações não confirmadas são revertidas em um instantâneo de banco de dados recém-criado porque o Mecanismo de Banco de Dados executa a recuperação após a criação do instantâneo (as transações no banco de dados não são afetadas).

Mas isso ainda não explica por que uma grande parte do arquivo de log é frequentemente lida no meu cenário de produção (e ocasionalmente na reprodução fornecida aqui). Acho que não tenho tantas transações em voo em um determinado momento no meu aplicativo, e certamente não há nenhuma na reprodução aqui.

sql-server sql-server-2016
  • 1 respostas
  • 977 Views
Martin Hope
Luciano Andress Martini
Asked: 2018-03-14 09:08:06 +0800 CST

Postgresql: O que o valor default_statistics_target realmente significa?

  • 16

Aumentar o valor default_statistics_target pode tornar seu banco de dados mais rápido, especialmente após a análise....

Lendo este artigo, vejo que https://discuss.pivotal.io/hc/en-us/articles/201581033-default-statistics-target-Explained

(...) em resumo e em termos básicos, este parâmetro controla a forma como as estatísticas são coletadas, sendo o valor 1 a estatística menos estimada/precisa e o valor 1000 a estatística mais precisa, obviamente com gasto de tempo/recursos ( CPU , memória etc ) / espaço . Normalmente, o valor padrão é suficiente para obter um plano preciso, mas se você tiver uma distribuição de dados complexa/ou uma coluna for referenciada na consulta com bastante frequência, definir um valor mais alto pode ajudar a obter estatísticas melhores na tabela e, portanto, uma melhor plano para o otimizador executar.

É uma boa explicação, mas, por exemplo, se eu definir default_statistics_target= 1000, o que 1000 realmente significa? São 1000 kilobytes de estatísticas sendo geradas? ou talvez sejam 1000 linhas das tabelas analisadas? Talvez seja 1000 colunas? ou talvez 1000 segundos para cada análise...

Então, minha pergunta é como esse número está realmente afetando a análise ou o planejador de consultas? Óbvio eu entendo que default_statistics_target = 1000 vai ter mais tempo que 100, para rodar analise, e que 1000 vai gerar estatísticas melhores...

postgresql
  • 1 respostas
  • 7682 Views
Martin Hope
Burleigh Bear
Asked: 2017-12-22 16:38:26 +0800 CST

O que pode dar errado usando a mesma sequência em várias tabelas no postgres?

  • 16

Estamos pensando em usar uma sequência compartilhada para atribuir ids a chaves primárias para todas as tabelas em nosso banco de dados. Existem cerca de 100 deles. Apenas alguns são inseridos com frequência e regularidade. Queremos descartar que seja "uma ideia terrível por um motivo óbvio" antes de passarmos para a fase de realmente experimentá-lo e testá-lo em carga.

Nosso pico de carga é da ordem de 1.000 inserções por segundo, em algumas tabelas.

Nossa pesquisa até agora indica que - a velocidade de geração de sequência não deve ser um problema - a fragmentação de sequência (lacunas) acontecerá, mas não deve ser um problema - a exaustão de id não será um problema

Não temos certeza se estamos perdendo outras grandes coisas. Ficaríamos gratos pelas opiniões das pessoas, especialmente de pessoas que tentaram antes e tiveram experiências positivas ou negativas.

Por contexto - temos duas motivações principais para fazer isso.

Uma motivação para fazer isso é para que possamos definir um monte de dicionários (nós os chamamos de escopos) e ter palavras legíveis para humanos atribuídas a esses ids, então queremos ter certeza de que ids em tabelas diferentes nunca se sobreponham. Assim, em um escopo, id 12345 pode receber o valor "Green" e em outro pode ser atribuído "Verde". (Na verdade, não o usamos para internacionalização, mas podemos um dia).

A outra motivação é tornar mais fácil ter várias implantações no campo e saber (definindo exclusivamente a sequência de cada par de dígitos mais significativos) que nossas implantações não sobreporão as chaves primárias. (Como um GUID lite).

postgresql sequence
  • 4 respostas
  • 6502 Views
Martin Hope
ldrg
Asked: 2017-11-05 19:18:50 +0800 CST

A cobertura de índices no PostgreSQL ajuda as colunas JOIN?

  • 16

Eu tenho um monte de tabelas que se parecem vagamente com isso:

CREATE TABLE table1(id INTEGER PRIMARY KEY, t1c1 INTEGER, t1c2 INTEGER);
CREATE TABLE table2(id INTEGER PRIMARY KEY, t1 INTEGER REFERENCES table1(id), t2c1 INTEGER);

E eu faço muitas junções onde estou tentando filtrar na tabela unida para obter coisas da primeira tabela, assim:

SELECT t1c1
FROM table1
JOIN table2 ON table2.t1 = table1.id
WHERE t2c1 = 42;

Quando vou escrever índices para uma tabela, olho para as colunas que são usadas na cláusula WHERE e construo índices para satisfazê-las. Então, para esta consulta, eu acabaria escrevendo um índice como este:

CREATE INDEX ON table2 (t2c1);

E esse índice é pelo menos elegível para uso nessa consulta.

Minha pergunta é que, se eu escrever um índice assim:

CREATE INDEX ON table2 (t2c1, t1);

O índice será usado como um índice de cobertura para ajudar o JOIN na consulta acima? Devo alterar minha estratégia de escrita de índice para cobrir colunas de chave estrangeira?

postgresql index
  • 2 respostas
  • 30015 Views
Martin Hope
i-one
Asked: 2017-10-06 08:11:48 +0800 CST

Prevenção de deadlock de MERGE

  • 16

Em um de nossos bancos de dados temos uma tabela que é acessada de forma intensiva e concorrente por várias threads. Threads atualizam ou inserem linhas via MERGE. Há também threads que excluem linhas ocasionalmente, portanto, os dados da tabela são muito voláteis. Threads que fazem upserts sofrem de deadlock algumas vezes. O problema é semelhante ao descrito nesta pergunta. A diferença, porém, é que no nosso caso cada thread atualiza ou insere exatamente uma linha .

A configuração simplificada está a seguir. A tabela é heap com dois índices não clusterizados exclusivos sobre

CREATE TABLE [Cache]
(
    [UID] uniqueidentifier NOT NULL CONSTRAINT DF_Cache_UID DEFAULT (newid()),
    [ItemKey] varchar(200) NOT NULL,
    [FileName] nvarchar(255) NOT NULL,
    [Expires] datetime2(2) NOT NULL,
    CONSTRAINT [PK_Cache] PRIMARY KEY NONCLUSTERED ([UID])
)
GO
CREATE UNIQUE INDEX IX_Cache ON [Cache] ([ItemKey]);
GO

e a consulta típica é

DECLARE
    @itemKey varchar(200) = 'Item_0F3C43A6A6A14255B2EA977EA730EDF2',
    @fileName nvarchar(255) = 'File_0F3C43A6A6A14255B2EA977EA730EDF2.dat';

MERGE INTO [Cache] WITH (HOLDLOCK) T
USING (
    VALUES (@itemKey, @fileName, dateadd(minute, 10, sysdatetime()))
) S(ItemKey, FileName, Expires)
ON T.ItemKey = S.ItemKey
WHEN MATCHED THEN
    UPDATE
    SET
        T.FileName = S.FileName,
        T.Expires = S.Expires
WHEN NOT MATCHED THEN
    INSERT (ItemKey, FileName, Expires)
    VALUES (S.ItemKey, S.FileName, S.Expires)
OUTPUT deleted.FileName;

ou seja, a correspondência acontece por chave de índice exclusiva. A dica HOLDLOCKestá aqui, por causa da simultaneidade (como recomendado aqui ).

Eu fiz uma pequena investigação e o seguinte é o que eu encontrei.

Na maioria dos casos, o plano de execução da consulta é

plano de execução de busca de índice

com o seguinte padrão de bloqueio

padrão de bloqueio de busca de índice

ou seja IX, bloqueio no objeto seguido por bloqueios mais granulares.

Às vezes, no entanto, o plano de execução da consulta é diferente

plano de execução de varredura de tabela

(esta forma de plano pode ser forçada adicionando INDEX(0)dica) e seu padrão de travamento é

padrão de bloqueio de varredura de tabela

Xbloqueio de aviso colocado no objeto depois de IXjá ter sido colocado.

Como dois IXsão compatíveis, mas dois Xnão são, o que acontece em concorrência é

impasse

gráfico de impasse

impasse !

E aqui surge a primeira parte da questão . A colocação Xde bloqueio no objeto é IXelegível? Não é bug?

A documentação informa:

Os bloqueios de intenção são denominados bloqueios de intenção porque são adquiridos antes de um bloqueio no nível inferior e, portanto, sinalizam a intenção de colocar bloqueios em um nível inferior .

e também

IX significa a intenção de atualizar apenas algumas das linhas em vez de todas elas

então, colocar o Xbloqueio no objeto depois IXparece MUITO suspeito para mim.

Primeiro, tentei evitar o bloqueio tentando adicionar dicas de bloqueio de tabela

MERGE INTO [Cache] WITH (HOLDLOCK, TABLOCK) T

e

MERGE INTO [Cache] WITH (HOLDLOCK, TABLOCKX) T

com o TABLOCKpadrão de travamento no lugar torna-se

mesclar padrão de bloqueio de tablock holdlock

e com o TABLOCKXpadrão de bloqueio é

mesclar holdlock tablockx padrão de bloqueio

como dois SIX(assim como dois X) não são compatíveis, isso evita o deadlock efetivamente, mas, infelizmente, também impede a simultaneidade (o que não é desejado).

Minhas próximas tentativas foram adicionar PAGLOCKe ROWLOCKtornar os bloqueios mais granulares e reduzir a contenção. Ambos não tem efeito (o Xobjeto ainda foi observado imediatamente após IX).

Minha tentativa final foi forçar a forma do plano de execução "boa" com um bom bloqueio granular adicionando FORCESEEKdica

MERGE INTO [Cache] WITH (HOLDLOCK, FORCESEEK(IX_Cache(ItemKey))) T

e funcionou.

E aqui surge a segunda parte da questão . Pode acontecer que FORCESEEKseja ignorado e um padrão de bloqueio ruim seja usado? (Como mencionei, PAGLOCKe ROWLOCKforam ignorados aparentemente).


Adicionar UPDLOCKnão tem efeito ( Xno objeto ainda observável depois IX).

Tornar IX_Cacheo índice agrupado, conforme previsto, funcionou. Isso levou ao planejamento com busca de índice clusterizado e bloqueio granular. Além disso, tentei forçar o Clustered Index Scan que também mostrava o bloqueio granular.

No entanto. Observação adicional. Na configuração original, mesmo com o FORCESEEK(IX_Cache(ItemKey)))local, se alguém alterar @itemKeya declaração da variável de varchar(200) para nvarchar(200) , o plano de execução se tornará

índice busca plano de execução com nvarchar

veja que seek é usado, MAS o padrão de bloqueio neste caso mostra novamente Xo bloqueio colocado no objeto após IX.

Assim, parece que a busca forçada não garante necessariamente bloqueios granulares (e, portanto, ausência de deadlocks). Não estou confiante de que o índice clusterizado garanta o bloqueio granular. Ou não?

Meu entendimento (corrija-me se estiver errado) é que o bloqueio é situacional em grande medida, e certa forma de plano de execução não implica em determinado padrão de bloqueio.

A questão sobre a elegibilidade de colocar o Xbloqueio no objeto depois IXde ainda aberto. E se for elegível, há algo que se possa fazer para evitar o bloqueio de objetos?

sql-server execution-plan
  • 1 respostas
  • 9398 Views
Martin Hope
davetapley
Asked: 2017-07-29 10:58:26 +0800 CST

Postgres sugere "Truncar tabela ... ao mesmo tempo"

  • 16

Ao executar:

TRUNCATE TABLE YYYYY RESTART IDENTITY

Estou vendo esta mensagem de erro:

ERROR:  cannot truncate a table referenced in a foreign key constraint
DETAIL:  Table "XXXXX" references "YYYYY".
HINT:  Truncate table "XXXXX" at the same time, or use TRUNCATE ... CASCADE.

Das duas sugestões em HINT:

  1. Usar TRUNCATE ... CASCADEfaz sentido e funciona, mas é menos explícito porque é preciso inspecionar YYYYYpara ver onde vai a cascata. Isso me faz querer tentar a outra opção:

  2. Truncate table "XXXXX" at the same time, mas minha pergunta:

    O que significa truncar uma tabela at the same time?


Eu tentei adicionar um TRUNCATE XXXXX...(e envolvê-los em um BEGIN/ COMMIT), mas isso gera o mesmo erro.

postgresql truncate
  • 2 respostas
  • 14528 Views
Martin Hope
Sabuncu
Asked: 2017-07-03 06:59:50 +0800 CST

Por que INFORMATION_SCHEMA não é exibido na interface do usuário do MySQL Workbench por padrão?

  • 16

Estou executando o MySQL Workbench 6.3 CE. Veja a seguir a aparência padrão da interface do usuário:

![digite a descrição da imagem aqui

Posso consultar o banco de dados INFORMATION_SCHEMA, mas ele não é mostrado por padrão na seção SCHEMAS no painel do navegador à esquerda. Por que isso acontece e como posso fazer com que esse banco de dados apareça no referido painel?

mysql-workbench
  • 1 respostas
  • 15217 Views
Martin Hope
beldaz
Asked: 2017-06-03 17:26:26 +0800 CST

Postgresql habilitando extensões sem superusuário

  • 16

Tenho um servidor PostgreSQL 9.5 no qual tenho scripts que criam funções e bancos de dados para usuários automaticamente. Dentro desses bancos de dados, seria útil habilitar extensões específicas (por exemplo, pgcrypto), mas, pelo que entendi, é preciso ser um superusuário para executar o CREATE EXTENSION. Existe uma maneira de habilitar essas extensões sem fazer login manualmente com uma conta de superusuário?

postgresql permissions
  • 1 respostas
  • 26247 Views
Martin Hope
Greg
Asked: 2017-05-30 19:06:19 +0800 CST

Diferença entre Procurar Predicado e Predicado

  • 16

Estou tentando ajustar o desempenho de uma consulta que temos no SQL Server 2014 Enterprise.

Eu abri o plano de consulta real no SQL Sentry Plan Explorer e posso ver em um nó que ele tem um predicado de busca e também um predicado

Qual é a diferença entre Seek Predicate e Predicate ?

insira a descrição da imagem aqui

Observação: posso ver que há muitos problemas com este nó (por exemplo, as linhas Estimated vs Actual, o IO residual), mas a pergunta não se relaciona a nada disso.

performance sql-server-2014
  • 1 respostas
  • 10673 Views
Prev
Próximo

Sidebar

Stats

  • Perguntas 205573
  • respostas 270741
  • best respostas 135370
  • utilizador 68524
  • Highest score
  • respostas
  • Marko Smith

    conectar ao servidor PostgreSQL: FATAL: nenhuma entrada pg_hba.conf para o host

    • 12 respostas
  • Marko Smith

    Como fazer a saída do sqlplus aparecer em uma linha?

    • 3 respostas
  • Marko Smith

    Selecione qual tem data máxima ou data mais recente

    • 3 respostas
  • Marko Smith

    Como faço para listar todos os esquemas no PostgreSQL?

    • 4 respostas
  • Marko Smith

    Listar todas as colunas de uma tabela especificada

    • 5 respostas
  • Marko Smith

    Como usar o sqlplus para se conectar a um banco de dados Oracle localizado em outro host sem modificar meu próprio tnsnames.ora

    • 4 respostas
  • Marko Smith

    Como você mysqldump tabela (s) específica (s)?

    • 4 respostas
  • Marko Smith

    Listar os privilégios do banco de dados usando o psql

    • 10 respostas
  • Marko Smith

    Como inserir valores em uma tabela de uma consulta de seleção no PostgreSQL?

    • 4 respostas
  • Marko Smith

    Como faço para listar todos os bancos de dados e tabelas usando o psql?

    • 7 respostas
  • Martin Hope
    Jin conectar ao servidor PostgreSQL: FATAL: nenhuma entrada pg_hba.conf para o host 2014-12-02 02:54:58 +0800 CST
  • Martin Hope
    Stéphane Como faço para listar todos os esquemas no PostgreSQL? 2013-04-16 11:19:16 +0800 CST
  • Martin Hope
    Mike Walsh Por que o log de transações continua crescendo ou fica sem espaço? 2012-12-05 18:11:22 +0800 CST
  • Martin Hope
    Stephane Rolland Listar todas as colunas de uma tabela especificada 2012-08-14 04:44:44 +0800 CST
  • Martin Hope
    haxney O MySQL pode realizar consultas razoavelmente em bilhões de linhas? 2012-07-03 11:36:13 +0800 CST
  • Martin Hope
    qazwsx Como posso monitorar o andamento de uma importação de um arquivo .sql grande? 2012-05-03 08:54:41 +0800 CST
  • Martin Hope
    markdorison Como você mysqldump tabela (s) específica (s)? 2011-12-17 12:39:37 +0800 CST
  • Martin Hope
    Jonas Como posso cronometrar consultas SQL usando psql? 2011-06-04 02:22:54 +0800 CST
  • Martin Hope
    Jonas Como inserir valores em uma tabela de uma consulta de seleção no PostgreSQL? 2011-05-28 00:33:05 +0800 CST
  • Martin Hope
    Jonas Como faço para listar todos os bancos de dados e tabelas usando o psql? 2011-02-18 00:45:49 +0800 CST

Hot tag

sql-server mysql postgresql sql-server-2014 sql-server-2016 oracle sql-server-2008 database-design query-performance sql-server-2017

Explore

  • Início
  • Perguntas
    • Recentes
    • Highest score
  • tag
  • help

Footer

AskOverflow.Dev

About Us

  • About Us
  • Contact Us

Legal Stuff

  • Privacy Policy

Language

  • Pt
  • Server
  • Unix

© 2023 AskOverflow.DEV All Rights Reserve