O Debugbotão está presente nesta versão do SSMS:
Mas não está presente na versão 18, preview 4:
Eu tentei de várias maneiras adicionar o Debugbotão ao meu SSMS, mas não obtive sucesso.
Existe uma maneira de adicionar o Debugbotão ao SSMS v18?
Vou tentar explicar meus mal-entendidos com o seguinte exemplo.
Não entendi os fundamentos do Bitmap Heap Scan Node. Considere a consulta SELECT customerid, username FROM customers WHERE customerid < 1000 AND username <'user100';cujo plano é este:
Bitmap Heap Scan on customers (cost=25.76..61.62 rows=10 width=13) (actual time=0.077..0.077 rows=2 loops=1)
Recheck Cond: (((username)::text < 'user100'::text) AND (customerid < 1000))
-> BitmapAnd (cost=25.76..25.76 rows=10 width=0) (actual time=0.073..0.073 rows=0 loops=1)
-> Bitmap Index Scan on ix_cust_username (cost=0.00..5.75 rows=200 width=0) (actual time=0.006..0.006 rows=2 loops=1)
Index Cond: ((username)::text < 'user100'::text)
-> Bitmap Index Scan on customers_pkey (cost=0.00..19.75 rows=1000 width=0) (actual time=0.065..0.065 rows=999 loops=1)
Index Cond: (customerid < 1000)
Minha compreensão deste nó :
Conforme explicado lá , os bitmap heap scanblocos de tabela de leitura em ordem sequencial, portanto, não produz sobrecarga de acesso à tabela aleatória que acontece ao fazer apenas Index Scan.
Depois Index Scande feito, o PostgreSQL não sabe como buscar as linhas de forma otimizada, para evitar o desnecessário heap blocks reads(ou hitsse houver um hot cache). Então, para descobrir isso, ele gera a estrutura ( Bitmap Index Scan) chamada bitmapque no meu caso está sendo gerada gerando dois bitmaps dos índices e executando BITWISE AND. Uma vez que o bitmap foi gerado, ele agora pode ler a tabela de forma otimizada em uma ordem sequencial, evitando arquivos desnecessários heap I/O-operations.
Esse é o lugar onde muitas perguntas vêm.
PERGUNTA: Temos apenas um bitmap. Como o PostgreSQL sabe por apenas um bitmap qualquer coisa sobre a ordem física das linhas? Ou gera o bitmap para que qualquer elemento dele possa ser mapeado facilmente para o ponteiro de uma página? Se sim, isso explica tudo, mas é apenas minha suposição.
Então, podemos dizer simplesmente que bitmap heap scan -> bitmap index scané como uma varredura sequencial, mas apenas da parte apropriada da tabela?
Eu tenho uma função definida pelo usuário:
create function ut_FooFunc(@fooID bigint, @anotherParam tinyint)
returns @tbl Table (Field1 int, Field2 varchar(100))
as
begin
-- blah blah
end
Agora eu quero juntar isso em outra tabela, assim:
select f.ID, f.Desc, u.Field1, u.Field2
from Foo f
join ut_FooFunc(f.ID, 1) u -- doesn't work
where f.SomeCriterion = 1
Em outras palavras, para todos os Fooregistros onde SomeCriterioné 1, quero ver o Foo IDand Desc, juntamente com os valores de Field1e Field2que são retornados ut_FooFuncpara uma entrada de Foo.ID.
Qual é a sintaxe para fazer isso?
Entendo que, após a instalação, o PostgreSQL não possui senha para seu usuário root do banco de dados (postgres):
postgres=# select usename, passwd is null from pg_shadow;
usename | ?column?
----------+----------
postgres | t
(1 row)
... e é aconselhável configurá-lo com:
alter role postgres password '<<very-secret>>';
(e, em seguida, atualize o pg_hba.confarquivo de acordo)
Minha pergunta é: qual é o SQL a ser usado para voltar à situação anterior quando nenhuma senha era necessária para user postgres.
Em geral, como posso remover o requisito de senha para qualquer função? Não estou perguntando como alterar a senha, mas como remover o requisito de senha ( passwdcoluna nula na tabela pg_shadow).
Ao configurar um novo SQL Server, uso o seguinte código para determinar um bom ponto de partida para a MAXDOPconfiguração:
/*
This will recommend a MAXDOP setting appropriate for your machine's NUMA memory
configuration. You will need to evaluate this setting in a non-production
environment before moving it to production.
MAXDOP can be configured using:
EXEC sp_configure 'max degree of parallelism',X;
RECONFIGURE
If this instance is hosting a Sharepoint database, you MUST specify MAXDOP=1
(URL wrapped for readability)
http://blogs.msdn.com/b/rcormier/archive/2012/10/25/
you-shall-configure-your-maxdop-when-using-sharepoint-2013.aspx
Biztalk (all versions, including 2010):
MAXDOP = 1 is only required on the BizTalk Message Box
database server(s), and must not be changed; all other servers hosting other
BizTalk Server databases may return this value to 0 if set.
http://support.microsoft.com/kb/899000
*/
DECLARE @CoreCount int;
DECLARE @NumaNodes int;
SET @CoreCount = (SELECT i.cpu_count from sys.dm_os_sys_info i);
SET @NumaNodes = (
SELECT MAX(c.memory_node_id) + 1
FROM sys.dm_os_memory_clerks c
WHERE memory_node_id < 64
);
IF @CoreCount > 4 /* If less than 5 cores, don't bother. */
BEGIN
DECLARE @MaxDOP int;
/* 3/4 of Total Cores in Machine */
SET @MaxDOP = @CoreCount * 0.75;
/* if @MaxDOP is greater than the per NUMA node
Core Count, set @MaxDOP = per NUMA node core count
*/
IF @MaxDOP > (@CoreCount / @NumaNodes)
SET @MaxDOP = (@CoreCount / @NumaNodes) * 0.75;
/*
Reduce @MaxDOP to an even number
*/
SET @MaxDOP = @MaxDOP - (@MaxDOP % 2);
/* Cap MAXDOP at 8, according to Microsoft */
IF @MaxDOP > 8 SET @MaxDOP = 8;
PRINT 'Suggested MAXDOP = ' + CAST(@MaxDOP as varchar(max));
END
ELSE
BEGIN
PRINT 'Suggested MAXDOP = 0 since you have less than 4 cores total.';
PRINT 'This is the default setting, you likely do not need to do';
PRINT 'anything.';
END
Percebo que isso é um pouco subjetivo e pode variar com base em muitas coisas; no entanto, estou tentando criar um código abrangente para usar como ponto de partida para um novo servidor.
Alguém tem alguma entrada sobre este código?
Estou tentando usar uma MERGEinstrução para inserir ou excluir linhas de uma tabela, mas só quero agir em um subconjunto dessas linhas. A documentação para MERGEtem um aviso muito forte:
É importante especificar apenas as colunas da tabela de destino que são usadas para fins de correspondência. Ou seja, especifique as colunas da tabela de destino que são comparadas com a coluna correspondente da tabela de origem. Não tente melhorar o desempenho da consulta filtrando linhas na tabela de destino na cláusula ON, como especificando AND NOT target_table.column_x = value. Fazer isso pode retornar resultados inesperados e incorretos.
mas é exatamente isso que parece que tenho que fazer para fazer meu MERGEtrabalho.
Os dados que tenho são uma tabela padrão de junção de muitos para muitos de itens para categorias (por exemplo, quais itens estão incluídos em quais categorias) assim:
CategoryId ItemId
========== ======
1 1
1 2
1 3
2 1
2 3
3 5
3 6
4 5
O que preciso fazer é substituir efetivamente todas as linhas de uma categoria específica por uma nova lista de itens. Minha tentativa inicial de fazer isso se parece com isso:
MERGE INTO CategoryItem AS TARGET
USING (
SELECT ItemId FROM SomeExternalDataSource WHERE CategoryId = 2
) AS SOURCE
ON SOURCE.ItemId = TARGET.ItemId AND TARGET.CategoryId = 2
WHEN NOT MATCHED BY TARGET THEN
INSERT ( CategoryId, ItemId )
VALUES ( 2, ItemId )
WHEN NOT MATCHED BY SOURCE AND TARGET.CategoryId = 2 THEN
DELETE ;
Isso parece estar funcionando em meus testes, mas estou fazendo exatamente o que o MSDN me avisa explicitamente para não fazer. Isso me deixa preocupado com a possibilidade de ter problemas inesperados mais tarde, mas não consigo ver nenhuma outra maneira de fazer minhas MERGElinhas afetar apenas com o valor de campo específico ( CategoryId = 2) e ignorar linhas de outras categorias.
Existe uma maneira "mais correta" de alcançar esse mesmo resultado? E quais são os "resultados inesperados ou incorretos" sobre os quais o MSDN está me alertando?
De acordo com a documentação do PostgreSQL , não há diferença de desempenho entre VARCHAR, VARCHAR(n)e TEXT.
Devo adicionar um limite de comprimento arbitrário a uma coluna de nome ou endereço ?
Edit: Não é um dupe de:
Eu sei que o CHARtipo é uma relíquia do passado e estou interessado não apenas no desempenho, mas em outros prós e contras, como Erwin afirmou em sua incrível resposta.
Processamos um feed de dados de rotina de um cliente que acabou de refatorar seu banco de dados de um formulário que parece familiar (uma linha por entidade, uma coluna por atributo) para um que parece desconhecido para mim (uma linha por entidade por atributo):
Antes: uma coluna por atributo
ID Ht_cm wt_kg Age_yr ...
1 190 82 43 ...
2 170 60 22 ...
3 205 90 51 ...
Depois: uma coluna para todos os atributos
ID Metric Value
1 Ht_cm 190
1 Wt_kg 82
1 Age_yr 43
1 ...
2 Ht_cm 170
2 Wt_kg 60
2 Age_yr 22
2 ...
3 Ht_cm 205
3 Wt_kg 90
3 Age_yr 51
3 ...
Existe um nome para essa estrutura de banco de dados? Quais são as vantagens relativas? A maneira antiga parece mais fácil de colocar restrições de validade em atributos específicos (não nulos, não negativos, etc.) e mais fácil de calcular médias. Mas posso ver como pode ser mais fácil adicionar novos atributos sem refatorar o banco de dados. Esta é uma forma padrão/preferida de estruturar dados?
Fui ensinado a não usar o nome Idpara a coluna de identidade de minhas tabelas, mas ultimamente tenho usado de qualquer maneira porque é simples, curto e muito descritivo sobre o que os dados realmente são.
Já vi pessoas sugerirem prefixar Ido nome da tabela, mas isso parece dar mais trabalho para a pessoa que escreve as consultas SQL (ou o programador, se você estiver usando um ORM como o Entity Framework), principalmente em nomes de tabela mais longos, como CustomerProductIdouAgencyGroupAssignementId
Um fornecedor terceirizado que contratamos para criar algo para nós nomeou todas as suas colunas de identidade Identapenas para evitar o uso de Id. A princípio, pensei que eles faziam isso porque Idera uma palavra-chave, mas quando examinei, descobri que Idnão é uma palavra-chave no SQL Server 2005, que é o que estamos usando.
Então, por que as pessoas recomendam não usar o nome Idpara uma coluna de identidade?
Editar: Para esclarecer, não estou perguntando qual convenção de nomenclatura usar ou argumentos para usar uma convenção de nomenclatura sobre a outra. Eu só quero saber por que é recomendado não usar Idpara o nome da coluna de identidade.
Sou um único programador, não um dba, e para mim o banco de dados é apenas um local para armazenar meus dados. Como costumo criar pequenos aplicativos e normalmente uso um ORM para acesso a dados, é muito mais fácil trabalhar com um nome de campo comum para o campo de identidade. Quero saber o que estou perdendo ao fazer isso e se há algum motivo realmente bom para não fazer isso.
Tenho uma tabela assim:
ID | Val | Kind
----------------------
1 | 1337 | 2
2 | 1337 | 1
3 | 3 | 4
4 | 3 | 4
Eu quero fazer um SELECTque retornará apenas a primeira linha para cada um Val, ordenando por Kind.
Saída de amostra:
ID | Val | Kind
----------------------
2 | 1337 | 1
3 | 3 | 4
Como posso construir esta consulta?