All perguntas(dba)

Eu tenho uma tabela que consiste em um ID de registro, um ID de grupo (vinculando 1 ou mais registros em um grupo) e um valor de hash para cada registro.

CREATE TABLE HashTable(
    RecordID VARCHAR(255),
    GroupIdentifier VARCHAR(255),
    Hash VARCHAR (255),
    GroupHashList VARCHAR(4000)
)

(Eu sei que esta não é uma tabela eficiente, mas é apenas uma tabela temporária para os propósitos deste exemplo).

Eu quero gerar um hash para cada grupo, então pensei que a maneira mais simples seria concatenar os hashes de cada registro do grupo. RecordIDs são exclusivos, mas o que esses registros se relacionam não são necessariamente exclusivos, portanto, os hashes podem ser duplicados. O objetivo disso é sinalizar grupos totalmente duplicados, ou seja, um grupo onde todos os registros desse grupo são duplicados de todos os registros de outro grupo. A GUI precisa que todos os membros do grupo tenham o mesmo hash para reconhecê-los como um grupo duplicado.

Estou usando STRING_AGG para concatenar os hashes individuais dos registros no grupo e classificá-los pelo hash para garantir que obtenha a mesma sequência de caracteres para grupos duplicados. Na verdade, não me importo com a ordem dos hashes, desde que seja sempre a mesma. Quando executo como uma consulta SELECT, funciona bem e posso ver strings idênticas para grupos duplicados. Quando eu pego essa mesma consulta SELECT e a coloco em uma consulta UPDATE, a ordenação parece se perder.

SELECT STRING_AGG([Hash],';') WITHIN GROUP (ORDER BY [Hash] ASC) 
FROM HashTable
GROUP BY [GroupIdentifier]

Isso fornece os resultados (para um exemplo de par de grupos duplicados):

73F294873462B2BA0E930FD16DCCB7;90E749375DF806CB6E3F5CA48FFA38;E44256CE7CFCB971EB679BAC25A697
73F294873462B2BA0E930FD16DCCB7;90E749375DF806CB6E3F5CA48FFA38;E44256CE7CFCB971EB679BAC25A697

Quando coloco esse mesmo código na consulta UPDATE, ele não os classifica corretamente:

UPDATE HashTable
SET GroupHashList = c.HashList
FROM HashTable
INNER JOIN (
    SELECT (STRING_AGG([Hash],';') WITHIN GROUP (ORDER BY [Hash] ASC)) AS [HashList],
        [GroupIdentifier]
    FROM HashTable
    GROUP BY [GroupIdentifier]) c
ON c.[GroupIdentifier] = HashTable.[GroupIdentifier]

Resultados para os mesmos dois grupos que são gravados na tabela:

73F294873462B2BA0E930FD16DCCB7;90E749375DF806CB6E3F5CA48FFA38;E44256CE7CFCB971EB679BAC25A697
73F294873462B2BA0E930FD16DCCB7;E44256CE7CFCB971EB679BAC25A697;90E749375DF806CB6E3F5CA48FFA38

o que estou perdendo?

O que estou recebendo pela primeira vez é

Hash1; Hash2; Hash3
Hash1; Hash2; Hash3

Mas quando está na consulta UPDATE, recebo

Hash1; Hash2; Hash3
Hash1; Hash3; Hash2

A consulta de atualização é classificada por ID de registro, embora eu não saiba se isso é coincidência. ( https://dbfiddle.uk/CPG1-z2l )

O seguinte T-SQL leva cerca de 25 segundos na minha máquina com SSMS v17.9:

DECLARE @outer_loop INT = 0,
@big_string_for_u VARCHAR(8000);

SET NOCOUNT ON;

WHILE @outer_loop < 50000000
BEGIN
    SET @big_string_for_u = 'ZZZZZZZZZZ';
    SET @outer_loop = @outer_loop + 1;
END;

Acumula 532 ms de ASYNC_NETWORK_IOesperas de acordo com sys.dm_exec_session_wait_statse sys.dm_os_wait_stats. O tempo total de espera aumenta à medida que o número de iterações de loop aumenta. Usando o wait_completedevento estendido, posso ver que a espera acontece aproximadamente a cada 43 ms, com algumas exceções:

Além disso, posso obter as pilhas de chamadas que ocorrem logo antes da ASYNC_NETWORK_IOespera:

sqldk.dll!SOS_DispatcherBase::GetTrack+0x7f6c
sqldk.dll!SOS_Scheduler::PromotePendingTask+0x204
sqldk.dll!SOS_Task::PostWait+0x5f
sqldk.dll!SOS_Scheduler::Suspend+0xb15
sqllang.dll!CSECCNGProvider::GetBCryptHandleFromAlgID+0xf6af
sqllang.dll!CSECCNGProvider::GetBCryptHandleFromAlgID+0xf44c
sqllang.dll!SNIPacketRelease+0xd63
sqllang.dll!SNIPacketRelease+0x2097
sqllang.dll!SNIPacketRelease+0x1f99
sqllang.dll!SNIPacketRelease+0x18fe
sqllang.dll!CAutoExecuteAsContext::Restore+0x52d
sqllang.dll!CSQLSource::Execute+0x151b
sqllang.dll!CSQLSource::Execute+0xe13
sqllang.dll!CSQLSource::Execute+0x474
sqllang.dll!SNIPacketRelease+0x165d
sqllang.dll!CValOdsRow::CValOdsRow+0xa92
sqllang.dll!CValOdsRow::CValOdsRow+0x883
sqldk.dll!ClockHand::Statistic::RecordClockHandStats+0x15d
sqldk.dll!ClockHand::Statistic::RecordClockHandStats+0x638
sqldk.dll!ClockHand::Statistic::RecordClockHandStats+0x2ad
sqldk.dll!SystemThread::MakeMiniSOSThread+0xdf8
sqldk.dll!SystemThread::MakeMiniSOSThread+0xf00
sqldk.dll!SystemThread::MakeMiniSOSThread+0x667
sqldk.dll!SystemThread::MakeMiniSOSThread+0xbb9

Finalmente, notei que o SSMS usa uma quantidade surpreendente de CPU durante o loop (cerca de meio núcleo em média). Não consigo descobrir o que o SSMS está fazendo durante esse período.

Por que um loop simples causa ASYNC_NETWORK_IOesperas quando executado por meio do SSMS? A única saída que pareço obter do cliente dessa execução de consulta é "Comandos concluídos com êxito". mensagem.

Eu acho que esta é uma pergunta de UI/Configuração do DBeaver, mas não consigo ver onde estão as mensagens ao executar um script (Alt-X).

No PGAdminIII, eu executaria um script e veria a NOTICEsaída:

No DBeaver, o mesmo script não sai na guia "Estatísticas". Mas não tenho certeza se é aqui que devo procurar as mensagens:

Estou trabalhando em um sistema de relatórios que exigirá grandes consultas de seleção, mas é baseado em um banco de dados que é preenchido apenas uma vez. O sistema de gerenciamento de banco de dados é o Microsoft SQL Server 2017. Provavelmente há uma maneira melhor de projetar um sistema como esse, mas vamos abordar isso teoricamente.

Teoricamente falando:

1. Se tivermos um banco de dados muito grande (mais de 150 milhões de linhas em várias tabelas)
2. E podemos assumir que o banco de dados será preenchido apenas uma vez.

A indexação de todas as combinações de colunas possíveis pode ter um impacto negativo no desempenho de uma consulta selecionada?

SELECT json_array_elements('["one", "two"]'::json)

dá resultado

| json_array_elements |
| :------------------ |
| "um" |
| "dois" |

Eu gostaria de ter o mesmo, mas sem as aspas:

one
two

Parece que não posso usar ->>aqui porque não tenho nomes de campos no JSON. É apenas um array de strings.

Versão do Postgres: PostgreSQL 10.0 em x86_64-apple-darwin, compilado por i686-apple-darwin11-llvm-gcc-4.2 (GCC) 4.2.1 (Baseado na Apple Inc. build 5658) (LLVM build 2336.11.00), 64- pedaço

Em nosso banco de dados, temos várias entradas com acentos graves, acentos circunflexos ou carons (aka hačeks). Esses acentos são coletivamente também conhecidos como sinais diacríticos .

Agora, nossos usuários desejam encontrar entradas que incluam esses sinais diacríticos quando pesquisam entradas sem. Vou mostrar isso com um exemplo simples:

Em nosso banco de dados temos a entrada (contato com nome)

Millière

...então este nome está correto no país em que a pessoa vive.

Em nosso país não temos caracteres com sinais diacríticos, portanto nosso usuário procura por Milliere. Nenhum resultado aparece, como èobviamente não corresponde e.

Eu não tenho idéia de como isso poderia ser realizado como é, è, êe muitos mais estão disponíveis (e este é apenas um exemplo para carta e...).

(A outra maneira seria muito mais fácil, pois eu poderia simplesmente substituir todas as letras por caron/haček pela básica. Obviamente, nossos usuários querem a versão correta do nome no banco de dados, não a aleijada.)

Eu estava investigando alguns bloqueios quando vi uma consulta parecida com esta:

SELECT SomeField FROM SomeTable NOLOCK

Eu vi o NOLOCKe fiquei curioso como ele poderia estar bloqueando outras consultas, neste caso DELETEdeclarações. Dei uma olhada rápida nas fechaduras usando sp_locke aqui está o que vi:

DB      S   GRANT

TAB     IS  GRANT

PAG    S    GRANT

Agora, meu entendimento é que NOLOCKdeveria ter apenas um bloqueio de estabilidade de esquema, por que foi então pegando um bloqueio IS?

Minha curiosidade foi aguçada. Eu olhei no BOL e vi que havia duas maneiras de usá-lo, WITH (NOLOCK)e o obsoleto (NOLOCK), então decidi experimentá-los. Eu executei as seguintes consultas seguidas pela execução sp_lock:

SELECT SomeField FROM SomeTable WITH (NOLOCK)

CONCESSÃO DB S

CONCESSÃO TAB Sch-S

SELECT SomeField FROM SomeTable (NOLOCK)

CONCESSÃO DB S

CONCESSÃO TAB Sch-S

Com certeza, existem meus bloqueios de estabilidade de esquema. Então, minha pergunta é esta: o que está acontecendo aqui? Se a sintaxe aceita para usar NOLOCK for WITH (NOLOCK)ou (NOLOCK), por que a consulta não apresenta um erro quando é executada simplesmente NOLOCK(sem os parênteses)? Se for suportado, por que está agarrando um bloqueio IS? O que estou perdendo aqui? Estive pesquisando online por uma resposta, mas até agora não consegui.

Eu testei isso em 2008R2 e 2012.

Uma função com valor de tabela com várias instruções retorna seu resultado em uma variável de tabela.

Esses resultados são reutilizados ou a função é sempre totalmente avaliada toda vez que é chamada?

Eu tenho um único banco de dados de cerca de 4,5 GB em execução em um servidor com 8 GB de RAM. A grande maioria das tabelas são MyIsam (cerca de 4,3 GB), mas em breve estarei convertendo algumas delas para InnoDB. (Será um processo lento, concentrando-se inicialmente nas tabelas de gravação mais intensiva).

Há algo de errado em executar um servidor dedicado onde existem os dois tipos de mecanismos de armazenamento?

Um agrupamento tem alguma influência sobre a velocidade de uma consulta? O tamanho de uma tabela muda dependendo do agrupamento?

Se eu quiser criar um site que suporte todos os idiomas possíveis (vamos, por exemplo, Google), qual seria o agrupamento recomendado?

Vou precisar armazenar caracteres como 日本語, minhas pesquisas no site terão que retornar somethingpara a sóméthíngentrada, deve ser insensível a maiúsculas e minúsculas também.

Como sei qual é a melhor escolha a fazer? Qual agrupamento se adapta melhor a este caso?