Cedilhas são mutações aplicadas a letras de alguns idiomas, como português, francês, turco e romeno. Algumas palavras: "coração", "açúcar", "linhaça" (letras 'Ç', 'Ş', ...).
Como escolher uma collation que ignore cedillas para comparação? Elas não são acentos.
Este post do blog ensina que:
SQL_Latin1_General_CP1_CI_AI: considera cedilhasLatin1_General_CI_AI: ignora cedilhasQual é a diferença? Não está claro no nome da collation.
Sei que adicionar uma restrição de chave estrangeira requer uma varredura de tabela e um SHARE ROW EXCLUSIVEbloqueio em ambas as tabelas.
Para evitar a possível varredura de tabela longa, a restrição pode ser adicionada com a NOT VALIDabordagem. Mas estou pensando, ao adicionar uma nova coluna, você também deve usar NOT VALIDou o Postgres é inteligente o suficiente para reconhecer que é uma nova coluna e, portanto, a tabela inteira não precisa ser varrida?
Estou usando Django, e o SQL gerado para adicionar uma coluna de chave estrangeira se parece com isto:
ALTER TABLE
"example"
ADD
COLUMN "new_column_id" integer NULL CONSTRAINT "example_new_column_id_fk" REFERENCES "another_table"("id") DEFERRABLE INITIALLY DEFERRED;
SET
CONSTRAINTS "example_new_column_id_b781b6be_fk" IMMEDIATE;
Agora estou criando um BD de sistema bancário que é mais conveniente no caso da entidade de conta para torná-la a chave primária composta de chaves estrangeiras (id da agência, id do cliente, id do serviço, quatro inteiros gerados para exclusividade) para serviço de contexto como empréstimo etc., ou torná-los apenas chaves estrangeiras normais. Se você puder fornecer um caso mais geral em que a chave composta seja o melhor caso de uso
Minha consulta está tendo problema de desempenho de Parameter Sniffing? Eu mantive meu índice não clusterizado sugerido pelo plano de execução da consulta, mas ainda tenho dúvidas se isso é parameter sniffing ou outra coisa. Por favor, verifique a consulta abaixo:
declare @orgid int=22,
@salesperson int=0
select
pd.col1,dd.col1
from t1 pd
inner join (select max(doId) doid,personId from t2 where productId=99 and personId>0
and effectDate IS NOT NULL group by personId) d on pd.personId=d.personId
join t2 dd on d.doid=dd.doId
join (select max(requestId) requestid,doId from t3 group by doId ) p on dd.doId=p.doId
join t3 pp on p.requestid=pp.requestIdjoin person prn on cp.personId=prn.personId
where pd.organizationId=@orgId
and (@salesperson=0 or cp.personId=@salesperson)
order by pd.patientName
Essa linha criará um problema?
(@salesperson=0 or cp.personId=@salesperson)
Meu software, compatível com todas as versões do SQL2016 e superiores, incluindo o SQL Azure, trava quando o SQL 2022 é inferior à versão 16.0.1135.2 ou inferior à 16.0.4165.4 - dependendo do RTM, GDR, CU (que estou tendo dificuldade em entender a arquitetura de versão que a MS usa)
Eu escrevi este código para descobrir se uma atualização de SQL é necessária
-- if it's Version 16
IF (select substring(convert(varchar(20),SERVERPROPERTY('productversion')),1,charindex('.',convert(varchar(20),SERVERPROPERTY('productversion')))-1))='16'
-- If so is it 16.0.1xxxxxxx or 16.0.4xxxxxxxx
IF (select substring(convert(varchar(20),SERVERPROPERTY('productversion')),1,charindex('16.0.',convert(varchar(20),SERVERPROPERTY('productversion')))))='1'
-- if 16.0.1 it needs to be < 16.0.1135.2
BEGIN
if (select substring(convert(varchar(20),SERVERPROPERTY('productversion')),charindex('16.0.',convert(varchar(20),SERVERPROPERTY('productversion'))),len(convert(varchar(20),SERVERPROPERTY('productversion')))))<'16.0.1135.2'
select 1
END
ELSE
BEGIN
-- if 16.0.4 it needs to be < 16.0.4165.4
IF (select substring(convert(varchar(20),SERVERPROPERTY('productversion')),1,charindex('16.0.',convert(varchar(20),SERVERPROPERTY('productversion')))))='4'
if (select substring(convert(varchar(20),SERVERPROPERTY('productversion')),charindex('16.0.',convert(varchar(20),SERVERPROPERTY('productversion'))),len(convert(varchar(20),SERVERPROPERTY('productversion')))))<'16.0.4165.4'
select 1
END
Meu problema é que em 16.0.YYYY.z, não acho que posso confiar no primeiro Y para me dizer qual branch devo olhar porque, olhando para versões anteriores do SQL, no mesmo branch o primeiro Y pode mudar de dígito... O que estou procurando são as 2 versões atualizadas antes de 2024-11-12. Quero ser sinalizado se a versão do SQL2022 instalada não incluir as atualizações de 2024-11-12.
Queremos que o usuário saiba que ele precisa de no mínimo 16.0.1135.2 ou 16.0.4165.4. Minha preocupação é selecionar o branch (='1' ou ='4') na consulta. Não acho que será confiável com o tempo (o dígito pode mudar), pois não tenho certeza da convenção que a MS usa.
O Software tem mais de 30000 scripts (mais de 30 anos de desenvolvimento) e milhares de clientes. As atualizações são feitas por especialistas (e não pelo cliente). Como ele é atualizado quatro vezes por ano, queremos adicionar um aviso durante a atualização se descobrirmos que o servidor SQL é incompatível para que o especialista possa tomar medidas.
Tenho uma implantação do PostgreSQL 15 que contém uma tabela particionada na ordem de dezenas de milhões de registros.
Tenho brincado com a criação de índices e estou surpreso com o pouco espaço que um índice btree está usando.
Então, a tabela de partição dummy_name_partition_01tem cerca de 13 milhões de registros. Não tenho certeza se é relevante, mas os registros podem ficar um pouco grandes, com média de 2,66 KiB por registro (a partição tem ~30 GiB sem contar índices).
Uma das colunas (chamada record_type), que é a coluna com a qual estou brincando com índices, armazena uma string pequena (< 50 caracteres). Embora seja um tipo TEXT e não um ENUM, seu valor sempre será um de cerca de ~300 strings possíveis.
Inicialmente, criei um índice BRIN para essa record_typecoluna para economizar no uso do disco. Parece que o tamanho do índice é de apenas 1 MiB no disco. De fato, minúsculo.
Agora, estou tendo problemas com o postgres realmente usando esse índice BRIN. Ele insiste em fazer varreduras sequenciais, então é como se o índice brin fosse inútil. Eu estava com medo de que um índice btree fosse muito grande, mas então eu descartei o índice BRIN e o criei como BTREE, e seu tamanho é de apenas 92 MiB. Eu esperava algo na faixa de pelo menos 1 GiB!
Para medir o tamanho do índice, estou consultando a information_schema.tablestabela e usando as funções pg_table_size, pg_indexes_size. Ou seja, consultei o tamanho do índice com pg_indexes_sizequando não havia índice, então executei depois de criar o índice e apenas peguei a diferença como sendo o tamanho do índice. Claro que fiz isso algumas vezes para poder obter os números de BRIN vs BTREE.
O índice é tão simples quanto a CREATE INDEX foo_bar ON dummy_namy_partition_01 (record_type)para btree, e o mesmo, mas a USING BRINpara o índice brin.
Agora, eu me pergunto: o Postgres de alguma forma armazena um ponteiro para os dados na record_typecoluna em vez de armazenar strings duplicadas por toda parte e então essa seria a razão para o índice estar em quase cem MiBs em vez de alguns gigabytes? Ou, o que está acontecendo aqui?
A primeira nota de incompatibilidade para notas PG17:
Funções usadas por índices de expressão e visualizações materializadas que precisam referenciar esquemas não padrão devem especificar um caminho de pesquisa durante a criação da função.
A recriação de visualizações materializadas (que funcionavam bem no PG 14-16) usando funções que dependem da ltreeextensão instalada publicfalha no PG17 com:
ERROR: operator does not exist: public.ltree <@ public.ltree
LINE 3: code_b <@ code_a
CONTEXT: SQL function "myfunc" during inlining
Se eu adicionar set search_path = publicà definição da função conforme sugerido pelas notas de incompatibilidade, a visualização materializada poderá ser criada.
Mas, uma vez set search_pathadicionada, a função não pode mais ser usada: o planejador não coleta índices nos ltreetipos.
Existe uma solução alternativa para obter funções usadas em uma visualização materializada para pegar os ltreeoperadores em public? Ou para cutucar o planejador para usar os índices? Ou estou fazendo algo errado?
Para reproduzir, em um novo banco de dados PG 17.0 (e praticamente o mesmo em dockerizado PostgreSQL 17.1 (Debian 17.1-1.pgdg110+1)):
select version();
version
------------------------------------------------------------------------------------------------------------------------------
PostgreSQL 17.0 (Homebrew) on aarch64-apple-darwin24.1.0, compiled by Apple clang version 16.0.0 (clang-1600.0.26.4), 64-bit
-- check the default search path
SELECT setting FROM pg_settings WHERE name = 'search_path';
setting
-----------------
"$user", public
(1 row)
-- setup test data
create extension if not exists ltree;
create schema test;
create table test.table
(id serial primary key,
code ltree);
insert into test.table (code)
select
concat_ws('.',
rpad(trunc(random() * 10 + 1)::text, 3, '0'),
rpad(trunc(random() * 10 + 1)::text, 3, '0'),
rpad(trunc(random() * 100 + 1)::text, 3, '0'),
rpad(trunc(random() * 100 + 1)::text, 3, '0'),
rpad(trunc(random() * 100 + 1)::text, 3, '0')
)::ltree as code
from generate_series(1, 1000000) s(i);
create index on test.table using gist (code);
create index on test.table using btree (code);
-- create test function as per pg16 (no search path)
create or replace function test.myfunc(
code_a ltree,
code_b ltree)
RETURNS boolean language sql AS $$
SELECT
code_b <@ code_a
$$
immutable parallel safe;
-- test the function - it picks up the index
explain analyze
select
a.id
from test.table a
inner join (select * from test.table limit 10) as b
on test.myfunc(a.code, b.code);
QUERY PLAN
-----------------------------------------------------------------------------------------------------------------------------------------
Nested Loop (cost=0.41..15541.90 rows=100000 width=4) (actual time=0.105..1.078 rows=11 loops=1)
-> Limit (cost=0.00..0.20 rows=10 width=36) (actual time=0.015..0.019 rows=10 loops=1)
-> Seq Scan on "table" (cost=0.00..20310.00 rows=1000000 width=36) (actual time=0.014..0.016 rows=10 loops=1)
-> Index Scan using table_code_idx on "table" a (cost=0.41..1454.16 rows=10000 width=36) (actual time=0.086..0.104 rows=1 loops=10)
Index Cond: (code @> "table".code)
Planning Time: 1.475 ms
Execution Time: 1.175 ms
(7 rows)
-- try and use the function in a materialized view,
-- (works fine in PG14,PG16, fails on PG17)
create materialized view test.myview as
select
a.id
from test.table a
inner join (select * from test.table limit 10) as b
on test.myfunc(a.code, b.code);
ERROR: operator does not exist: public.ltree <@ public.ltree
LINE 3: code_b <@ code_a
^
HINT: No operator matches the given name and argument types. You might need to add explicit type casts.
QUERY:
SELECT
code_b <@ code_a
CONTEXT: SQL function "myfunc" during inlining
-- try specifying search_path as recommended in
-- PG17 release notes
create or replace function test.myfunc(
code_a ltree,
code_b ltree)
RETURNS boolean set search_path = public language sql AS $$
SELECT
code_b <@ code_a
$$
immutable parallel safe;
-- test the new function - it works, but does not pick up the index
explain analyze
select
a.id
from test.table a
inner join (select * from test.table limit 10) as b
on test.myfunc(a.code, b.code);
QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------------
Nested Loop (cost=0.00..2645310.33 rows=3333333 width=4) (actual time=0.335..6668.876 rows=11 loops=1)
Join Filter: test.myfunc(a.code, b.code)
Rows Removed by Join Filter: 9999989
-> Seq Scan on "table" a (cost=0.00..20310.00 rows=1000000 width=36) (actual time=0.034..46.823 rows=1000000 loops=1)
-> Materialize (cost=0.00..0.35 rows=10 width=32) (actual time=0.000..0.000 rows=10 loops=1000000)
-> Subquery Scan on b (cost=0.00..0.30 rows=10 width=32) (actual time=0.008..0.012 rows=10 loops=1)
-> Limit (cost=0.00..0.20 rows=10 width=36) (actual time=0.008..0.011 rows=10 loops=1)
-> Seq Scan on "table" (cost=0.00..20310.00 rows=1000000 width=36) (actual time=0.006..0.007 rows=10 loops=1)
Planning Time: 0.313 ms
Execution Time: 6668.912 ms
(10 rows)
-- Try using the updated func in materialized view
-- The view is successfully created (on this small sample),
-- but is impractical on larger data because it doesn't use the index
create materialized view test.myview as
select
a.id
from test.table a
inner join (select * from test.table limit 10) as b
on test.myfunc(a.code, b.code);
SELECT 11
Estou comparando os hashes de senha de logins SQL em nós AG. Dos vinte logins SQL, 15 têm os mesmos hashes nos 2 nós e 5 têm hashes diferentes.
Um hash diferente é um indicador de uma senha diferente ou um salt pode ter sido adicionado a algumas senhas e não a outras?
O ideal seria não usarmos logins SQL, mas em alguns casos somos forçados a isso
Deixe-me dar um exemplo. Existem duas tabelas:
Tbl1que tem colunas a( chave primária ), b, c( chave estrangeira para Tbl2chave primária (coluna x))Tbl2que possui colunas x( chave primária ), y.É possível fazer backup de todos os dados Tbl1e também incluir apenas os dados necessários para Tbl2satisfazer a restrição de chave estrangeira, e não um backup completo dos dados para Tbl2.
Tbl1
| um | b | c |
|---|---|---|
| 1 | x11111 | 2 |
| 2 | x22222 | 3 |
| 3 | x33333 | 4 |
Tbl2
| x | e |
|---|---|
| 1 | k11111 |
| 2 | k22222 |
| 3 | k33333 |
| 4 | k44444 |
| 5 | k55555 |
O que eu quero incluir no backup é o seguinte:
Tbl1
| um | b | c |
|---|---|---|
| 1 | x11111 | 2 |
| 2 | x22222 | 3 |
| 3 | x33333 | 4 |
Tbl2
| x | e |
|---|---|
| 2 | k22222 |
| 3 | k33333 |
| 4 | k44444 |
Do Tbl2 as seguintes linhas não estão incluídas:
| 1 | k11111 | => NÃO INCLUÍDO!
| 5 | k55555 | => NÃO INCLUÍDO!
Pelo que entendi, o SQL dinâmico faz parte de um lote. No entanto, quando listei para sqlserver.sql_batch_completedo seguinte
CREATE EVENT SESSION [CaptureBatch] ON SERVER
ADD EVENT sqlserver.sql_batch_completed(
ACTION(sqlserver.client_app_name,sqlserver.client_hostname,sqlserver.database_id,sqlserver.database_name,sqlserver.query_hash,sqlserver.query_plan_hash,sqlserver.sql_text)
WHERE ([sqlserver].[database_id]>(4)))
ADD TARGET package0.event_file(SET filename=N'CaptureBatch',max_rollover_files=(0))
WITH (STARTUP_STATE=ON);
GO
ALTER EVENT SESSION [CaptureBatch] ON SERVER
STATE = START;
Não consigo ver nenhuma chamada para EXECessa chamada também EXEC. Por exemplo, a linha final aqui não aparece no log do meu Evento Estendido.
CREATE PROCEDURE [TestThis]
AS
BEGIN
SELECT 'Test';
END
GO
EXEC (N'EXEC TestThis');
Por que isso? Esses tipos EXECnão são considerados um lote ou estou esquecendo de algo?
Não consigo encontrar nenhuma documentação detalhada sobre esse evento, então me perdoe se esqueci de alguma.