No trabalho, estamos pensando em adicionar uma réplica do Postgresql.
Estávamos nos perguntando se é possível criar visualizações e visualizações materializadas diretamente na réplica.
É possível executar o Assistente de Importação/Exportação do SQL Server puramente em um servidor remoto (por exemplo, de um banco de dados para outro no mesmo servidor remoto)?
Se eu configurar as conexões de origem/destino no Assistente em minha máquina local, só poderei inserir conexões com o servidor remoto como faria em minha máquina local. Não consigo entrar nas conexões porque o servidor remoto as faria. Se eu executar o Assistente, ele transferirá os dados por meio da minha máquina local, embora fosse muito mais rápido se o servidor remoto se conectasse diretamente à origem/destino.
Por exemplo:
- Um único SQL Server em uma máquina remota com dois bancos de dados: DB1 e DB2.
- SSMS na máquina local conectada ao SQL Server na máquina remota.
- Tarefa: copiar tabela (muito grande) de DB1 para DB2.
- Configure o Assistente de Importação/Exportação com conexões para ambas as tabelas.
- Problema: transferência de dados via máquina local (do DB1 para a máquina local para o DB2).
Examinei a documentação do Wizard , mas não consegui encontrar nenhuma descrição desse problema. Estou esquecendo de algo? Eu acho que a maioria dos servidores SQL são executados em alguma máquina remota e não localmente.
Os nós parecem estar usando mais memória do que quando estavam em execução com o Cassandra 2.1.
Quando os nós foram atualizados para uma versão mais recente do Cassandra, a utilização de memória nos servidores subitamente disparou, com alguns nós relatando erros de falta de memória. O que está causando esse comportamento?
Tenho a seguinte estrutura de tabela em meu banco de dados Postgres: tabela chat_channelpossui uma coluna otherUserIdque pode ser unida com tabela a coluna userIdde outra tabela, profile. A tabela profilepossui colunas userIdque podem ser unidas à coluna senderUserIdou recipientUserIdna tabela note.
Para qualquer linha que chat_channelcorresponda a determinados critérios de consulta, desejo extrair a única linha de profileonde chat_channel."otherUserId" = profile."userId"(como colunas extras retornadas da consulta). Também quero extrair colunas da linha correspondente notepara cada uma das duas userIdcorrespondências possíveis: where profile."userId" = note."senderUserId"e where profile."userId" = note."recipientUserId".
Estou tendo problemas para descobrir como criar um alias adequado de colunas para essa consulta duplamente aninhada, visto que a consulta interna ingressa na mesma tabela duas vezes.
Tenho que criar um alias para as colunas, pois estou retornando colunas da mesma tabela duas vezes nas linhas de resultados. Além disso, as tabelas compartilham colunas com o mesmo nome (principalmente id).
Tentativa (1):
SELECT "chat_channel"."id" "chat_channel.id",
"chat_channel"."channelId" "chat_channel.channelId",
"chat_channel"."userId" "chat_channel.userId",
"chat_channel"."otherUserId" "chat_channel.otherUserId",
"chat_channel"."sortByDateTime" "chat_channel.sortByDateTime",
"profile_other_user"."userId" "profile_other_user.userId",
"profile_other_user"."name" "profile_other_user.name",
"note_viewer_sent"."id" "note_viewer_sent.id", -- (a)
"note_viewer_sent"."senderUserId" "note_viewer_sent.senderUserId",
"note_viewer_sent"."recipientUserId" "note_viewer_sent.recipientUserId",
"note_viewer_sent"."noteText" "note_viewer_sent.noteText",
"note_viewer_received"."id" "note_viewer_received.id",
"note_viewer_received"."senderUserId" "note_viewer_received.senderUserId",
"note_viewer_received"."recipientUserId" "note_viewer_received.recipientUserId",
"note_viewer_received"."noteText" "note_viewer_received.noteText"
FROM "chat_channel"
LEFT JOIN LATERAL (
SELECT "profile_other_user"."id",
"profile_other_user"."userId",
"profile_other_user"."name"
FROM "profile" "profile_other_user"
LEFT JOIN LATERAL (
SELECT "note_viewer_sent"."id",
"note_viewer_sent"."senderUserId",
"note_viewer_sent"."recipientUserId",
"note_viewer_sent"."noteText"
FROM "note" "note_viewer_sent" -- (b)
WHERE "note_viewer_sent"."recipientUserId" = "profile_other_user"."userId"
AND "note_viewer_sent"."senderUserId" = $viewerUserId
LIMIT 1
) AS "note_viewer_sent" ON TRUE -- (c)
LEFT JOIN LATERAL (
SELECT "note_viewer_received"."id",
"note_viewer_received"."senderUserId",
"note_viewer_received"."recipientUserId",
"note_viewer_received"."noteText"
FROM "note" "note_viewer_received"
WHERE "note_viewer_received"."senderUserId" = "profile_other_user"."userId"
AND "note_viewer_received"."recipientUserId" = $viewerUserId
LIMIT 1
) AS "note_viewer_received" ON TRUE
WHERE "chat_channel"."otherUserId" = "profile_other_user"."userId"
LIMIT 1
) AS "profile_other_user" ON TRUE
WHERE "chat_channel"."userId" = $viewerUserId
ORDER BY "chat_channel"."sortByDateTime" DESC
Problemas com isso:
- Isso dá
ERROR: missing FROM-clause entry for table "note_viewer_sent"na linha marcada-- (a). - Tentar criar um alias para a tabela (
-- (b)) não resolve o problema. - Tentar criar um alias para os resultados da consulta mais profunda (
-- (c)) não resolve o problema.
Tentativa (2):
No entanto, se eu fizer a FROMcláusula de nível superior
FROM "chat_channel", "note" "note_viewer_sent", "note" "note_viewer_received"
então o erro não é mais gerado, mas as WHEREcláusulas mais internas parecem ser ignoradas:
WHERE "note_viewer_sent"."recipientUserId" = "profile_other_user"."userId"
AND "note_viewer_sent"."senderUserId" = $viewerUserId
Especificamente, cada linha do conjunto de resultados contém colunas da mesma linha (errada) de notes, para a qual a WHEREcondição nem sequer é válida.
Além disso, parece que o efeito padrão de colocar várias tabelas FROMé obter um produto cruzado das tabelas. (Não posso reproduzir isso agora, mas a certa altura eu estava recebendo uma cópia de cada linha de profilepara cada linha de chat_channele as LIMIT 1consultas internas estavam sendo ignoradas.)
Alguma idéia sobre o que estou fazendo de errado aqui?
Temos um pacote SSIS que funciona diariamente à meia-noite. Ele extrai dados do Active Directory usando consulta ADSI e envia os dados para um CRM.
A única vez que “falha” é no domingo à noite. Aqui está o problema: ele foi bem-sucedido e envia um e-mail informando que foi bem-sucedido, mas recebemos uma mensagem de erro informando que houve falha no SQL Sentry, no relatório de trabalho no SSRS e no histórico de trabalho do SQL. A consulta quase sempre é concluída em menos de dois minutos e vemos os dados no CRM.
Não há outros trabalhos em execução no momento da execução, nem há trabalhos que começaram mais cedo e ainda estão em execução à meia-noite. Isso começou há quatro semanas e ninguém fez nenhuma alteração. Quando abordamos nossa equipe de infraestrutura/sistemas para perguntar sobre quaisquer alterações, eles disseram não e sugeriram que poderia ser a partir de backups. Não há trabalhos de backup SQL nativos em execução no momento. Duvido que seja a Veeam que está causando esse problema, mas pensei em mencioná-lo de qualquer maneira.
Esta versão do SQL Server é 14.0.3465.1.
Windows Server 2016 Standard versão 1607 e foi totalmente corrigido na última quarta-feira.
Esta é a mensagem de erro e a consulta:
select q1.employeeNumber, 'telephoneNumber'=CASE WHEN right(dbo.udf_GetNumeric(q1.telephoneNumber),10)='0' THEN null ELSE right(dbo.udf_GetNumeric(q1.telephoneNumber),10) END,
'mobile'=CASE WHEN right(dbo.udf_GetNumeric(q1.mobile),10)='0' THEN null ELSE right(dbo.udf_GetNumeric(q1.mobile),10) END,
q1.company, q1.Country, q2.[3DigitCode], q2.CountryCode
from (SELECT EmployeeNumber, phoneNumber, mobile, company, 'Country'=CASE WHEN co is null THEN 'United States' ELSE co END FROM OPENQUERY( ADSI, 'SELECT EmployeeNumber, phoneNumber, mobile, mail, company, co, c, countryCode FROM ''LDAP://MyServer/OU=MyCompany USERS,DC=MyCompany,DC=com'' WHERE objectCategory = ''Person'' e objectClass = ''User'' e EmployeeNumber>=0 e EmployeeNumber<200000 e userAccountControl <>''514'' e userAccountControl<>''66050''')) como q1 LEFT OUTER JOIN Map_AD_Codes q2 em q2.Country = q1.Country
Estou testando meu aplicativo Web, que é o Azure App Server + o Banco de Dados SQL do Azure.
Estou observando as métricas do painel de dados do Azure à medida que o testamos e a maioria das medidas (porcentagem de DTU, porcentagem de CPU etc.) tem uma média de 0,2% a 0,5%, chegando a 2% às vezes.
No insight de desempenho da consulta, o pior é 1,080 segundos, um é de 0,860 segundos e o restante é inferior a 0,5 segundos. Todas as minhas páginas de interesse têm 1 ou 2 consultas, embora o Entity Frameworks possa dividir uma consulta em várias.
As recomendações de desempenho e o ajuste automático não têm sugestões. Estou 99,9% confiante de que estou indexando tudo o que deveria.
Então, aqui estão as minhas questões:
- O que mais devo medir? O importante, eu acho, é quanto tempo uma consulta espera para ser executada. Se uma consulta leva 0,0001 segundos para ser executada, mas vem após a consulta de 1 segundo, então é 1,0001 antes de retornar. Vale a pena dar uma olhada? E se sim, onde/como posso encontrar isso?
- Acho que minhas dúvidas se reduzem ao que realmente preciso. Os que demoram é um modelo que possui 4 coleções que são preenchidas por meio de uma tabela de junção. E preciso dessas 4 coleções (não leio outras coleções do modelo que não preciso). Há algo que eu possa fazer para acelerar as duas consultas em mais de 0,5 segundo? Quando eu olhei para isso no passado, uma simples leitura na consulta não é mais rápida em um procedimento armazenado (e fazer isso perde as vantagens do Entity Framework).
(É mais uma questão de documentação do que de comportamento . Foi migrado do Stack Overflow como foi sugerido lá.)
Ao pesquisar a resposta para outra pergunta que exigia a extração de nós XML na ordem original dos elementos, me deparei com várias respostas ( aqui , aqui e aqui ) que usavam expressões do formato ROW_NUMBER() OVER (ORDER BY xml.node)e afirmavam ou implicavam que os valores de número de linha atribuídos seriam atribuído na ordem do documento XML.
No entanto, não consigo encontrar nenhum lugar que defina o comportamento do ORDER BY xml.node. Embora pareça permitido na OVER()cláusula, a documentação não menciona especificamente os nós XML.
Por exemplo, dado:
DECLARE @xml XML = '<root>
<node>One</node>
<node>Two</node>
<node>Three</node>
<node>Four</node>
</root>'
SELECT
ROW_NUMBER() OVER(ORDER BY xml.node) AS rn,
xml.node.value('./text()[1]', 'varchar(255)') AS value
FROM @xml.nodes('*/node') xml(node)
ORDER BY
ROW_NUMBER() OVER(ORDER BY xml.node)
Os seguintes resultados são retornados:
rn | value
----------
1 | One
2 | Two
3 | Three
4 | Four
Pergunta: Esses resultados são garantidos em algum lugar da documentação? Isso é aceito como comportamento garantido, mas não documentado? Ou este é outro caso como ORDER BY (SELECT NULL)esse que parece funcionar de forma anedótica para pequenos conjuntos de dados de origem aparentemente pré-ordenados, mas pode eventualmente falhar quando ampliado? A razão pela qual estou perguntando é que prefiro não recomendar o uso de uma técnica cujo comportamento e confiabilidade não são suportados pela documentação.
Curiosamente, embora um nó XML seja permitido em um window ORDER BY, ele não é permitido em um SELECT ... ORDER BY. Quando usado em uma cláusula select order-by comum, ORDER BY xml.nodegera o seguinte erro:
Msg 493 Nível 16 Estado 1 Linha 7
A coluna 'node' que foi retornada do método nodes() não pode ser usada diretamente. Ele só pode ser usado com um dos quatro métodos de tipo de dados XML, exist(), nodes(), query() e value(), ou em verificações IS NULL e IS NOT NULL.
A mensagem de erro acima não lista a função de janela OVER(ORDER BY ...)como um uso permitido.
A execução do Autovacuum leva muito tempo na minha instância postgres9.4 e minha pergunta é:
- Posso melhorar a velocidade do autovacuum eliminando o índice? Se eu encerrar o vácuo durante o processo, seus resultados entrarão em vigor, pois posso precisar encerrar o vácuo atual antes do índice de queda.
- Existe alguma outra maneira de acelerar o autovacuum.
Aumentei Maintenance_work_mem, configurei Vacuum_cost_limit para um valor mais alto e configurei Vacuum_cost_deplay para 0.
Qualquer sugestão ou ajuda seria apreciada!
Preciso construir uma consulta SQL, para MySQL 5.7, se for possível, para " GROUP BY" uide titleconcatenar a permissionscoluna e separar com um |? Estou dizendo GROUP BY, mas não sei se esse é o termo certo aqui.
+------+--------+------------------------------------------------+
| uid | title | permissions |
+------+--------+------------------------------------------------+
| 1438 | Delete | /_permission_set.php|/process.php|/command.php |
+------+--------+------------------------------------------------+
| 1438 | Remove | /_permission_set.php|/process.php|/command.php |
+------+--------+------------------------------------------------+
Eu tentei o seguinte SQL (como você pode ver neste DBFiddle ) mas não funcionou
SELECT uid, CONCAT('|', permissions)
FROM some_table
WHERE uid=1438
GROUP BY uid, permissions;
Estou executando um trabalho que exclui dados de 7 tabelas, 2 das quais contêm de 10 a 20 lakhs de registros. Mas o trabalho fica preso em um ponto ao excluir dados de uma tabela específica web_activity que contém apenas 42.000 registros. Na maioria das vezes, leva 4 horas. Mas às vezes leva apenas 7 minutos. Se esta for a questão do índice, então o que acontece no dia da execução de 7 minutos.
Existem 4 outros trabalhos que são executados paralelamente todos os dias e às vezes criam bloqueios, mas o bloqueio se deve à utilização de recursos por outros trabalhos.
O que me preocupa é: como posso reduzir as quatro horas para exclusão de apenas 42.000 registros da tabela web_activity?
Mais um ponto: há um grande número de leituras lógicas 2066225339. Não tenho certeza se essa é a causa ou não.
Ao fazer DBCC SHOWCONFIG para essas tabelas, ele mostra os dados abaixo:
Estou usando uma abordagem alternativa:
select Web_Activity_id into #Temp_web_activity from Web_Activity
where MONTH_NUMBER >=@min_month_to_delete
and year >= @year_to_delete;
DELETE FROM Web_Activity WHERE Web_Activity_id
in (select Web_Activity_id from #Temp_web_activity);
Será útil? Também tentei excluir em lotes na plataforma inferior, mas não ajudou muito.