All perguntas(dba)

eu uso este código para inserção em massa

BULK INSERT [Table]
FROM 'D:\phones.txt'
WITH
(
   ROWTERMINATOR = '0x0a'
)

Meus dados têm apenas uma coluna de 10 caracteres

Por exemplo

| 1234567890 |    
| 1234567891 |    
| 1234567892 |

Após salvar no banco de dados, executando o código a seguir, mostra o comprimento dos dados mais

SELECT TOP (1)
[Phone]
,LEN([Phone]) AS Phonelength
FROM [Table]

resultado

O caractere extra adicionado ao final do campo é a nova linha

Por que a nova linha foi adicionada?

Estou tentando usar as instruções aqui -

https://learn.microsoft.com/en-US/troubleshoot/sql/database-engine/security/transfer-logins-passwords-between-instances

para copiar logins entre o servidor que hospeda meu banco de dados primário e o servidor que hospeda minha réplica de leitura. Isso é importante para mim porque quero que todos os meus usuários que estão atualmente consultando o banco de dados de produção comecem a consultar a réplica de leitura.

Consigo criar os sprocs no banco de dados master do servidor primário, mas quando tento executar o sproc, conforme as instruções, recebo o seguinte erro:

EXEC sp_help_revlogin

Msg 229, Nível 14, Estado 5, Procedimento sp_help_revlogin, Linha 1 [Batch Start Line 0] A permissão EXECUTE foi negada no objeto 'sp_help_revlogin', banco de dados 'master', esquema 'dbo'.

Como faço para superar isso?

Estou usando o banco de dados SQL hospedado do Azure e estou conectado ao servidor como administrador (usando a conta definida como Microsoft Entra Admin).

Obrigada pelo Conselho!

Recentemente, consultei nossa ferramenta interna de inventário de banco de dados para obter uma lista de servidores, instâncias e bancos de dados e adicionei o status correspondente a cada servidor, instância e banco de dados.

Diagrama de Relacionamento

Server ˂-- 1 : n --˃ Instance ˂-- 1 : n --˃ Database
   ˄                    ˄                      ˄
   |                    |                      |
   |                  1 : 1                    |
   |                    |                      |
   |                    ˅                      |
   +-- 1 : 1 --˃     Status        ˂-- 1 : 1 --+

Leia como:
...um servidor pode ter múltiplas instâncias
...uma instância pode ter vários bancos de dados
...um servidor, uma instância e um banco de dados podem ter um status

Configurar

Tabela de status

CREATE TABLE [Status]
(
  StatusID int,
  StatusName char(20),
  );

Dados de status

INSERT INTO [Status] (StatusID, StatusName)
VALUES
(1,'Productive'),
(2,'Prod ACC'),
(3,'Prod APP'),
(4,'Test'),
(5,'Test ACC'),
(6,'Test APP'),
(7,'OFFLINE'),
(8,'Reserved'),
(9,'Decommisioned');

Tabela de servidores

CREATE TABLE [Server]
(
  ServerID int,
  ServerName char(20),
  ServerStatusID int
  );

Dados do servidor

INSERT INTO [Server] (ServerID, ServerName, ServerStatusID)
VALUES
(1,'FirstServer',1),
(2,'SecondServer',2),
(3,'ThirdServer',5),
(4,'FourthServer',8),
(5,'FifthServer',8);

Tabela de Instâncias

CREATE TABLE [Instance]
(
  InstanceID int,
  ServerID int,
  InstanceName char(30),
  InstanceStatusID int
  );

Dados da instância

INSERT INTO [Instance] 
  (InstanceID, ServerID, InstanceName, InstanceStatusID)
VALUES
(1,1,'GENERAL',1),
(2,1,'TAXES',1),
(3,2,'GENERAL',9),
(4,2,'SOCIAL',2),
(5,3,'GENERAL',5),
(6,3,'FBI',8),
(7,5,'COMINGSOON',8);

Tabela de banco de dados

CREATE TABLE [Database]
(
  DatabaseID int,
  InstanceID int,
  DatabaseName char(30),
  DatabaseStatusID int
  );

Dados do banco de dados

INSERT INTO [Database]
(DatabaseID, InstanceID, DatabaseName, DatabaseStatusID)
VALUES
(1,1,'master',1),
(2,1,'model',1),
(3,1,'msdb',1),
(4,1,'UserDB1',1),
(5,2,'master',1),
(6,2,'model',1),
(7,2,'msdb',1),
(8,2,'TaxesDB',1),
(9,4,'master',2),
(10,4,'model',2),
(11,4,'msdb',2),
(12,4,'HealthCareDB',2),
(13,5,'master',5),
(14,5,'model',5),
(15,5,'msdb',5),
(16,5,'GeneralUserDB',5),
(17,6,'master',8),
(18,6,'model',8),
(19,6,'msdb',8),
(20,6,'CriminalDB',8);

Instrução SELECT sem tabela de status envolvida

A instrução SELECT inicial envolvia simplesmente juntar as três tabelas: servidor, instância, banco de dados e era a seguinte:

-- Simple SELECT to get all information on Servers, Instances and Databases
-- The status of the server, instance or database is not returned
SELECT 
  ServerName, 
  InstanceName,
  DatabaseName 
  FROM [Server] as srv
    LEFT JOIN [Instance] as ins
      ON srv.ServerID = ins.ServerID
    LEFT JOIN [Database] as dbs
      ON ins.InstanceID = dbs.InstanceID;

Resultados de 1. Declaração

POR FAVOR, OBSERVE ISSO...

• existe um servidor sem instância e banco de dados
• há uma instância sem banco de dados

Instrução SELECT envolvendo tabela de status

Na próxima instrução decido adicionar o status a cada elemento (servidor, instância, banco de dados) e JOINeditar cada tabela com a Statustabela da seguinte forma:

-- Advanced SELECT to get all information on Servers, Instances and Databases 
-- including their status
SELECT 
  ServerName, 
  srvst.StatusName,
  InstanceName,
  insst.StatusName,
  DatabaseName,
  dbsst.StatusName
  FROM [Server] as srv
    JOIN [Status] as srvst
      ON srv.ServerStatusID = srvst.StatusID
    LEFT JOIN [Instance] as ins
      ON srv.ServerID = ins.ServerID
    JOIN [Status] as insst
      ON ins.InstanceStatusID = insst.StatusID
    LEFT JOIN [Database] as dbs
      ON ins.InstanceID = dbs.InstanceID
    JOIN [Status] as dbsst
      ON dbs.DatabaseStatusID = dbsst.StatusID
  ;

Resultados de 2. Declaração

Para minha surpresa o servidor sem instância e banco de dados e o servidor com instância mas sem banco de dados não estavam mais listados:

Descobertas / Solução

Depois de verificar várias opções com uma abordagem de tentativa e erro, descobri que JOINon the Statustable teve que ser alterado para a LEFT JOINpara permitir que a instrução exibisse o servidor sem uma instância ou um banco de dados e exibisse a instância sem um banco de dados :

-- Advanced SELECT to get all information on Servers, Instances and Databases 
-- including their status
SELECT 
  ServerName, 
  srvst.StatusName,
  InstanceName,
  insst.StatusName,
  DatabaseName,
  dbsst.StatusName
  FROM [Server] as srv
    LEFT JOIN [Status] as srvst
      ON srv.ServerStatusID = srvst.StatusID
    LEFT JOIN [Instance] as ins
      ON srv.ServerID = ins.ServerID
    LEFT JOIN [Status] as insst
      ON ins.InstanceStatusID = insst.StatusID
    LEFT JOIN [Database] as dbs
      ON ins.InstanceID = dbs.InstanceID
    LEFT JOIN [Status] as dbsst
      ON dbs.DatabaseStatusID = dbsst.StatusID;

Resultados de 3. Declaração

Material de referência

Aqui está um link para o db<>fiddle para reproduzir minhas descobertas.

Pergunta

Por que o SQL Server exige um LEFT JOINna Statustabela para itens filhos que não existem e para que a consulta exiba esses itens?

Estou restaurando bancos de dados em cada lado das minhas replicações transacionais e de mesclagem. Basicamente, a publicação e o assinante são inicialmente o mesmo banco de dados.

Ainda preciso executar o agente de snapshot para começar.

Como posso executar o snapshot sem executar os comandos bcp, ou seja, sem copiar os dados?

Estou bem com a estrutura de dados a ser copiada.

Eu tenho a consulta SQL abaixo que é executada de forma extremamente lenta. Quanto a esta consulta , isso se deve à instrução "ORDER BY", pois o Postgres está varrendo a changestabela por "contador" que pode ter milhões de valores. A remoção da instrução "ORDER BY" torna a consulta mais rápida.

Para a outra consulta mencionada acima, otimizei-a criando um índice em dois campos. Para esta consulta, entretanto, não tenho certeza de qual índice seria o correto. Tentei com um índice ativado, (item_id, counter)mas não ajudou em nada e não sei o que mais poderia tentar. Alguma sugestão?

Consulta SQL lenta:

SELECT "id", "item_id", "item_name", "type", "updated_time", "counter"
FROM "changes"
WHERE counter > -1
AND type = 2
AND item_id IN (SELECT item_id FROM user_items WHERE user_id = 'xxxx')
ORDER BY "counter" ASC
LIMIT 200;

EXPLICAR (ANALISAR, BUFFERS, CONFIGURAÇÕES) resultado:

------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 Limit  (cost=1001.15..27628.99 rows=200 width=99) (actual time=98730.912..116273.818 rows=200 loops=1)
   Buffers: shared hit=78113369 read=3224064 dirtied=3
   I/O Timings: read=137436.119
   ->  Gather Merge  (cost=1001.15..10431526.45 rows=78343 width=99) (actual time=98730.911..116273.783 rows=200 loops=1)
         Workers Planned: 2
         Workers Launched: 2
         Buffers: shared hit=78113369 read=3224064 dirtied=3
         I/O Timings: read=137436.119
         ->  Nested Loop  (cost=1.13..10421483.70 rows=32643 width=99) (actual time=98493.185..112919.559 rows=75 loops=3)
               Buffers: shared hit=78113369 read=3224064 dirtied=3
               I/O Timings: read=137436.119
               ->  Parallel Index Scan using changes_pkey on changes  (cost=0.56..5949383.56 rows=6197986 width=99) (actual time=1.076..42523.117 rows=4075591 loops=3)
                     Index Cond: (counter > '-1'::integer)
                     Filter: (type = 2)
                     Rows Removed by Filter: 10370914
                     Buffers: shared hit=18993521 read=2672415
                     I/O Timings: read=85551.814
               ->  Index Scan using user_items_item_id_index on user_items  (cost=0.56..0.72 rows=1 width=23) (actual time=0.017..0.017 rows=0 loops=12226772)
                     Index Cond: ((item_id)::text = (changes.item_id)::text)
                     Filter: ((user_id)::text = 'xxxx'::text)
                     Rows Removed by Filter: 1
                     Buffers: shared hit=59119848 read=551649 dirtied=3
                     I/O Timings: read=51884.305
 Settings: effective_cache_size = '16179496kB', jit = 'off', work_mem = '100000kB'
 Planning Time: 1.465 ms
 Execution Time: 116273.929 ms
(26 rows)

Índices:

"changes_pkey" PRIMARY KEY, btree (counter)
"changes_id_index" btree (id)
"changes_id_unique" UNIQUE CONSTRAINT, btree (id)
"changes_item_id_index" btree (item_id)
"changes_user_id_counter_index" btree (user_id, counter)
"changes_user_id_index" btree (user_id)

Tenho uma função cara e ela só fornece dados relevantes quando certas condições são atendidas. Esses dados são inseridos no resultado através de LEFT JOIN LATERAL conforme mostrado abaixo. Da forma como funciona agora, a função é chamada para cada linha.

Existe uma maneira de reescrevê-lo para que seja chamado apenas para linhas onde t1.type é igual a 5? O exemplo abaixo ainda chama a função para cada linha, embora eu tenha uma condição definida.

SELECT t1.name, t1.type, t2.col1, t2.col2
FROM table1 t1
LEFT JOIN LATERAL function_name(t1.col1, t1.col2) AS t2 ON t1.type = 5;

Caso de teste:

CREATE TABLE table1 (
    id SERIAL PRIMARY KEY,
    name VARCHAR(100),
    type INTEGER,
    col1 INTEGER,
    col2 INTEGER
);

-- Sample data for table1
INSERT INTO table1 (name, type, col1, col2)
VALUES
    ('Row 1', 5, 10, 20),
    ('Row 2', 7, 15, 25),
    ('Row 3', 10, 30, 40); 

CREATE OR REPLACE FUNCTION function_name(col1_arg INTEGER, col2_arg INTEGER)
RETURNS TABLE (col1 INTEGER, col2 INTEGER)
AS $$
BEGIN
    RAISE LOG 'Function called';
    RETURN QUERY SELECT col1_arg * 2 AS col1, col2_arg * 3 AS col2;
END;
$$ LANGUAGE plpgsql;


-- Test Query
SELECT t1.name, t1.type, t2.col1, t2.col2
FROM table1 t1
LEFT JOIN LATERAL function_name(t1.col1, t1.col2) AS t2 ON t1.type = 5;

Eu tenho um banco de dados chamado myAppDB em um SQL Server hospedado no Azure no Datacenter do Leste dos EUA. Criei um novo SQL Server no datacenter Centro-Sul dos EUA. Em seguida, criei uma réplica geográfica do myAppDB no servidor no leste dos EUA para o servidor no centro-sul dos EUA. Funcionou! Validei que o novo banco de dados é de fato somente leitura do SSMS e que os dados estão sendo bombeados à medida que o banco de dados primário é atualizado com transações em andamento.

O problema é que a interface do Azure para criar a réplica não permite a especificação do nome do banco de dados para a réplica.

Agora tenho dois bancos de dados diferentes em dois servidores diferentes, ambos com o mesmo nome - myAppDB . Fisicamente isso funciona, mas em termos de usabilidade, se estou trabalhando no SSMS com duas conexões de servidor de banco de dados, é confuso porque independente de qual banco de dados estou acessando, o SSMS reporta myAppDB . Prefiro que a réplica tenha um nome como myAppDB_Read apenas para trazer um pouco mais de clareza ao meu ambiente de trabalho. Existe alguma maneira de conseguir isso? (Já tentei o método padrão para renomear um banco de dados, mas recebi uma mensagem de erro informando que a operação não pode ser executada porque o banco de dados está em um relacionamento de replicação.)

Obrigada pelo Conselho!

Ao configurar servidores vinculados em um grupo de disponibilidade, preciso configurar os servidores vinculados no ouvinte do AG, bem como nos nós do AG? Herdei um AG de 2 nós que atualmente possui um conjunto de servidores vinculados no ouvinte e nos nós individuais (portanto, no SSMS, se eu me conectar aos nós e ao ouvinte, os servidores vinculados aparecerão em todos os três). Preciso adicionar um novo servidor vinculado, por isso não tenho certeza se preciso adicioná-lo no ouvinte ou apenas nos nós. Um de nossos desenvolvedores configurou o servidor vinculado no nó ativo e a conexão funcionou quando ele executou um script de teste conectado diretamente ao nó ativo, mas não conseguiu se conectar ao servidor vinculado se tentasse executar o script enquanto estava conectado ao ouvinte. Tivemos um problema semelhante ao executar procedimentos armazenados do banco de dados MASTER se o sp não estivesse instalado no ouvinte, mesmo que estivesse instalado no MASTER em ambos os nós. Não tenho certeza se esse é um comportamento normal ou se o AG foi configurado de alguma forma não padrão que está impedindo o funcionamento de sp's e servidores vinculados que não estão configurados no próprio ouvinte.

Meu objetivo é detectar tendências de preços de criptomoedas. Para isso, estou obtendo dados de preços OHLC para múltiplas moedas versus vários símbolos de cotação (por exemplo, velas para Bitcoin/USD, Bitcoin/EUR, Litecoin/USD etc.). Para realizar o cálculo de tendências utilizo o indicador Supertrend . Eu tenho as 2 tabelas a seguir:

-- This is where price candles AKA OHLC data gets stored. Interval can be '1h', '4h', '1d', etc.
CREATE TABLE ohlc (
    id integer DEFAULT nextval('ohlc_id_seq'::regclass) PRIMARY KEY,
    open numeric(65,30) NOT NULL,
    high numeric(65,30) NOT NULL,
    low numeric(65,30) NOT NULL,
    close numeric(65,30) NOT NULL,
    coinid character varying(255) NOT NULL REFERENCES coin(id) ON DELETE RESTRICT ON UPDATE CASCADE,
    closetime timestamp(3) without time zone NOT NULL,
    quotesymbol text NOT NULL,
    interval text NOT NULL
);

-- This is a caching table that gets automatically populated by a stored procedure that runs AFTER every ohlc insert. "trend" can be 'UP' or 'DOWN'.
CREATE TABLE supertrend (
    id integer DEFAULT nextval('supertrend_id_seq'::regclass) PRIMARY KEY,
    coinid character varying(255) NOT NULL REFERENCES coin(id) ON DELETE RESTRICT ON UPDATE CASCADE,
    quotesymbol text NOT NULL,
    date timestamp(3) without time zone NOT NULL,
    trend text NOT NULL,
    interval text NOT NULL
);

Dados de amostra para a tabela de supertendências:

Digamos que eu queira consultar a ORDER BY date DESCtendência mais recente () para cada coinid/quotesymbol com intervalo = '1d' (1 dia). Ou, em outras palavras WHERE interval = '1d' GROUP BY coinid, quotesymbol, quero também saber a tendência da tendência, por quantos períodos essa tendência já é a mesma.

Dados os dados da tabela de supertendências do exemplo acima, meu resultado deve ser semelhante a:

Para esclarecer o resultado acima: 'Bitcoin', 'usd' está 'UP' por 3 períodos, porque a tendência para Bitcoin/USD foi de alta em 18 de abril, 17 de abril e 16 de abril. E 'DOWN' em 15 de abril, veja o exemplo tabela de supertendências.

Além disso, gostaria de saber a supertendência agregada sobre todos os símbolos de cotação (via função de modo). Esse resultado deve ficar assim:

Para esclarecer o resultado acima: A tendência mais recente do Bitcoin/USD é 'UP, Bitcoin/EUR é 'EUR' é 'UP' e Bitcoin/CNY é 'DOWN'. A função mode pega ('UP', 'UP', 'DOWN') e retorna o valor que ocorre mais frequentemente ('UP').

Como posso consultar esses dados de maneira eficiente, considerando que a tabela de supertendências tem milhões ou bilhões de linhas?

Eu estava pensando em uma visão materializada, mas os intervalos mais baixos possíveis para essas supertendências são de 1 minuto e podem ser escritos em momentos distintos, de modo que pode ser uma taxa de atualização necessária muito alta.

Estou tentando evitar o uso de uma solução de cache separada como o Redis para manter simples a quantidade de arquitetura/ambientes necessários, mas acho que isso poderia ser uma opção especialmente para contadores.

Tenho tentado depurar uma consulta particularmente lenta que nunca é concluída (leva uma eternidade e eventualmente atinge o tempo limite) e descobri que tudo se resume à ORDER BYafirmação: se estiver lá, nunca será concluída; se eu removê-la, ela retornará instantaneamente.

Minha suposição era que não havia índice nesse campo, mas descobri que existe um:

CREATE UNIQUE INDEX changes_pkey ON public.changes USING btree (counter)

No entanto, isso não parece fazer nenhuma diferença, então estou me perguntando qual poderia ser o motivo? Talvez seja porque é um "ÍNDICE ÚNICO" diferente dos outros índices desta tabela?

Confira abaixo as dúvidas:

Nunca complete:

SELECT "id", "item_id", "item_name", "type", "updated_time", "counter"
FROM "changes"
WHERE counter > -1
AND (type = 1 OR type = 3)
AND user_id = 'xxxxxxx'
ORDER BY "counter" ASC
LIMIT 200

Conclui instantaneamente:

SELECT "id", "item_id", "item_name", "type", "updated_time", "counter"
FROM "changes"
WHERE counter > -1
AND (type = 1 OR type = 3)
AND user_id = 'xxxxxxx'
LIMIT 200

Índices nessa tabela:

changes              | changes_id_index                          | CREATE INDEX changes_id_index ON public.changes USING btree (id)
changes              | changes_id_unique                         | CREATE UNIQUE INDEX changes_id_unique ON public.changes USING btree (id)
changes              | changes_item_id_index                     | CREATE INDEX changes_item_id_index ON public.changes USING btree (item_id)
changes              | changes_pkey                              | CREATE UNIQUE INDEX changes_pkey ON public.changes USING btree (counter)
changes              | changes_user_id_index                     | CREATE INDEX changes_user_id_index ON public.changes USING btree (user_id)

postgres=> EXPLAIN SELECT "id", "item_id", "item_name", "type", "updated_time", "counter"
postgres-> FROM "changes"
postgres-> WHERE counter > -1
postgres-> AND (type = 1 OR type = 3)
postgres-> AND user_id = 'xxxxxxxx'
postgres-> ORDER BY "counter" ASC
postgres-> LIMIT 200;
                                             QUERY PLAN
-----------------------------------------------------------------------------------------------------
 Limit  (cost=0.56..9206.44 rows=200 width=99)
   ->  Index Scan using changes_pkey on changes  (cost=0.56..5746031.01 rows=124834 width=99)
         Index Cond: (counter > '-1'::integer)
         Filter: (((user_id)::text = 'xxxxxxxx'::text) AND ((type = 1) OR (type = 3)))
(4 rows)

* EXPLAIN para a consulta rápida:

postgres=> EXPLAIN SELECT "id", "item_id", "item_name", "type", "updated_time", "counter"
postgres-> FROM "changes"
postgres-> WHERE counter > -1
postgres-> AND (type = 1 OR type = 3)
postgres-> AND user_id = 'xxxxxxxx'
postgres-> LIMIT 200;
                                              QUERY PLAN
------------------------------------------------------------------------------------------------------
 Limit  (cost=0.56..1190.09 rows=200 width=99)
   ->  Index Scan using changes_user_id_index on changes  (cost=0.56..742468.10 rows=124834 width=99)
         Index Cond: ((user_id)::text = 'xxxxxxxx'::text)
         Filter: ((counter > '-1'::integer) AND ((type = 1) OR (type = 3)))
(4 rows)

Alguma ideia de qual poderia ser o motivo dessa consulta lenta?