Existem consultas em que quando clicamos em "executar", ele mostra algumas linhas e continua crescendo, mas a consulta ainda não terminou. No entanto, às vezes, ele espera até o final da consulta.
Por que isso acontece? Existe uma maneira de controlar isso?
Temos o SQL Server 2008 R2 (10.50.1600) em execução em um servidor Windows 2008 R2 virtual. Depois de atualizar a CPU de 1 núcleo para 4 e a RAM de 4 gb para 10 gb, notamos que o desempenho é pior.
Algumas observações que vejo:
Alguém já se deparou com este problema antes?
Por sp_BlitzErik, eu corri
EXEC dbo.sp_BlitzFirst @SinceStartup = 1;
Dando-me esses resultados.
Geralmente quando começo em um novo ambiente, costumo verificar onde estão os backups, quando foi feito o último full, quando foi a última restauração aplicada e verifico a segurança também.
A maneira que eu faço isso é via T-SQL.
Verifique os backups
;with Radhe as (
SELECT @@Servername as [Server_Name],
B.name as Database_Name,
ISNULL(STR(ABS(DATEDIFF(day, GetDate(), MAX(Backup_finish_date)))), 'NEVER') as DaysSinceLastBackup,
ISNULL(Convert(char(11), MAX(backup_finish_date), 113)+ ' ' + CONVERT(VARCHAR(8),MAX(backup_finish_date),108), 'NEVER') as LastBackupDate
,BackupSize_GB=CAST(COALESCE(MAX(A.BACKUP_SIZE),0)/1024.00/1024.00/1024.00 AS NUMERIC(18,2))
,BackupSize_MB=CAST(COALESCE(MAX(A.BACKUP_SIZE),0)/1024.00/1024.00 AS NUMERIC(18,2))
,media_set_id = MAX(A.media_set_id)
,[AVG Backup Duration]= AVG(CAST(DATEDIFF(s, A.backup_start_date, A.backup_finish_date) AS int))
,[Longest Backup Duration]= MAX(CAST(DATEDIFF(s, A.backup_start_date, A.backup_finish_date) AS int))
,A.type
FROM sys.databases B
LEFT OUTER JOIN msdb.dbo.backupset A
ON A.database_name = B.name
AND A.is_copy_only = 0
AND (A.type = 'D') --'D' full, 'L' log
GROUP BY B.Name, A.type
)
SELECT r.[Server_Name]
,r.Database_Name
,[Backup Type] = r.type
,r.DaysSinceLastBackup
,r.LastBackupDate
,r.BackupSize_GB
,r.BackupSize_MB
,F.physical_device_name
,r.[AVG Backup Duration]
,r.[Longest Backup Duration]
FROM Radhe r
LEFT OUTER JOIN msdb.dbo.backupmediafamily F
ON R.media_set_id = F.media_set_id
ORDER BY r.Server_Name, r.Database_Name
Para verificar a segurança:
Permissões de nível de servidor e banco de dados por Kenneth Fisher
Verificando as restaurações:
DECLARE @dbname sysname, @days int
SET @dbname = NULL --substitute for whatever database name you want
SET @days = -30 --previous number of days, script will default to 30
SELECT
rsh.destination_database_name AS [Database],
rsh.user_name AS [Restored By],
CASE WHEN rsh.restore_type = 'D' THEN 'Database'
WHEN rsh.restore_type = 'F' THEN 'File'
WHEN rsh.restore_type = 'G' THEN 'Filegroup'
WHEN rsh.restore_type = 'I' THEN 'Differential'
WHEN rsh.restore_type = 'L' THEN 'Log'
WHEN rsh.restore_type = 'V' THEN 'Verifyonly'
WHEN rsh.restore_type = 'R' THEN 'Revert'
ELSE rsh.restore_type
END AS [Restore Type],
rsh.restore_date AS [Restore Started],
bmf.physical_device_name AS [Restored From],
rf.destination_phys_name AS [Restored To]
FROM msdb.dbo.restorehistory rsh
INNER JOIN msdb.dbo.backupset bs ON rsh.backup_set_id = bs.backup_set_id
INNER JOIN msdb.dbo.restorefile rf ON rsh.restore_history_id = rf.restore_history_id
INNER JOIN msdb.dbo.backupmediafamily bmf ON bmf.media_set_id = bs.media_set_id
WHERE rsh.restore_date >= DATEADD(dd, ISNULL(@days, -30), GETDATE()) --want to search for previous days
--AND destination_database_name = ISNULL(@dbname, destination_database_name) --if no dbname, then return all
ORDER BY rsh.restore_history_id DESC
GO
Replicação:
--first thing - go to the publisher DB and find out the distributor server and DB
sp_helpdistributor
-- go to the distributor server and DB found above and run the following:
sp_replmonitorhelppublication null
Espelhamento:
--==============================================================================
-- query that shows the current state of each database in the mirroring
--==============================================================================
SELECT db_name(sd.[database_id]) AS [Database Name]
,sd.mirroring_state AS [Mirror State]
,sd.mirroring_state_desc AS [Mirror State]
,sd.mirroring_partner_name AS [Partner Name]
,sd.mirroring_role_desc AS [Mirror Role]
,sd.mirroring_safety_level_desc AS [Safety Level]
,sd.mirroring_witness_name AS [Witness]
,sd.mirroring_connection_timeout AS [Timeout(sec)]
FROM sys.database_mirroring AS sd
WHERE mirroring_guid IS NOT null
ORDER BY [Database Name];
SEMPRE
Eu uso o roteiro de Rudy Panigas
-- Always On Status Report
--
-- This script will show the status of the Alway On replication status
SELECT DISTINCT
primary_replica as 'Primary Server',
[endpoint_url] as 'End Point URL',
primary_recovery_health_desc as 'Primary Server Health Status',
secondary_recovery_health_desc as 'Secondary Server Health Status',
operational_state_desc as 'Operational State',
connected_state_desc as 'Connection State',
recovery_health_desc as 'Recovery Health',
synchronization_state_desc as 'Synchronization State',
database_state_desc as 'Database State',
JOIN_state_desc as 'Join State',
suspend_reason_desc as 'Suspended Reason',
availability_mode_desc as 'Availability Mode',
failover_mode_desc as 'Failover Mode',
primary_role_allow_connections_desc as 'Primary Connections Allowed',
secondary_role_allow_connections_desc as 'Secondary Connections Allowed',
create_date as 'Date Created',
modify_date as 'Date Modified',
[backup_priority] as 'Backup Priority',
role_desc as 'Role Type',
last_connect_error_description as 'Last Connection Error',
last_connect_error_timestamp as 'Last Connection Error Time',
last_sent_time as 'Last Data Send Time',
last_received_time as 'Last Data Recieved TIme',
last_hardened_time as 'Last Hardened Time',
last_redone_time as 'Last Redone Time',
log_send_queue_size as 'Log Send Queue Size',
log_send_rate as 'Log Send Rate',
redo_queue_size as 'Redo Queue Size',
redo_rate as 'Rate of Redo',
filestream_send_rate as 'Filestream Send Rate',
last_commit_time as ' Last Commit Time',
low_water_mark_for_ghosts as 'Low Water Mark for Ghosts'
FROM sys.dm_hadr_availability_group_states
JOIN sys.availability_replicas
ON sys.dm_hadr_availability_group_states.group_id = sys.availability_replicas.group_id
JOIN sys.dm_hadr_availability_replica_cluster_states
ON sys.dm_hadr_availability_group_states.group_id = sys.dm_hadr_availability_replica_cluster_states.group_id
JOIN sys.dm_hadr_availability_replica_states
ON sys.dm_hadr_availability_group_states.group_id = sys.dm_hadr_availability_replica_states.group_id
JOIN sys.dm_hadr_database_replica_states
ON sys.dm_hadr_availability_group_states.group_id = sys.dm_hadr_database_replica_states.group_id
WHERE operational_state_desc IS NOT NULL
AND database_state_desc IS NOT NULL
ORDER BY [endpoint_url] DESC
-- Testing section
/*
-- Suspend replication from primary
ALTER DATABASE [AdventureWorksLT2008] SET HADR SUSPEND
-- Resume replication from secondary
ALTER DATABASE [AdventureWorksLT2008] SET HADR RESUME
-- Force a manual failover of replication with data loss. MUST EXECUTE ON SECONDARY SQL SERVER
ALTER AVAILABILITY GROUP [AG-AdventureWorksLT2008] FORCE_FAILOVER_ALLOW_DATA_LOSS;
-- Force a manual failover of replication with NO data loss MUST EXECUTE ON SECONDARY SQL SERVER
--- YOU MUST EXECUTE THE FOLLOWING SCRIPT IN SQLCMD MODE.
--Connect VDV1OPS03
ALTER AVAILABILITY GROUP [AG-AdventureWorksLT2008] FAILOVER;
GO
--- YOU MUST EXECUTE THE FOLLOWING SCRIPT IN SQLCMD MODE.
--:Connect OPSDBSRV
ALTER AVAILABILITY GROUP [AG-AdventureWorksLT2008] FAILOVER;
GO
*/
Envio de Logs:
Diferentes maneiras de monitorar o Log Shipping para bancos de dados SQL Server
Pergunta:
Além do acima, há outras coisas que devo verificar ao iniciar um novo ambiente como uma questão de prioridade?
Eu quero uma maneira rápida de contar o número de linhas na minha tabela que tem vários milhões de linhas. Encontrei o post " MySQL: Fastest way to count number of rows " no Stack Overflow, que parecia resolver meu problema. Bayuah forneceu esta resposta:
SELECT
table_rows "Rows Count"
FROM
information_schema.tables
WHERE
table_name="Table_Name"
AND
table_schema="Database_Name";
O que eu gostei porque parece uma pesquisa em vez de uma varredura, então deve ser rápido, mas decidi testá-lo contra
SELECT COUNT(*) FROM table
para ver quanta diferença de desempenho havia.
Infelizmente, estou recebendo respostas diferentes, conforme mostrado abaixo:
Por que as respostas são diferentes em aproximadamente 2 milhões de linhas? Estou supondo que a consulta que executa uma verificação completa da tabela é o número mais preciso, mas existe uma maneira de obter o número correto sem ter que executar essa consulta lenta?
Corri ANALYZE TABLE data_302, que completou em 0,05 segundos. Quando executei a consulta novamente, agora obtive um resultado muito mais próximo de 34384599 linhas, mas ainda não é o mesmo número select count(*)de 34906061 linhas. A tabela de análise retorna imediatamente e processa em segundo plano? Acho que vale a pena mencionar que este é um banco de dados de teste e não está sendo gravado no momento.
Ninguém vai se importar se é apenas um caso de dizer a alguém o tamanho de uma tabela, mas eu queria passar a contagem de linhas para um pouco de código que usaria essa figura para criar consultas assíncronas de "tamanho igual" para consultar o banco de dados em paralelo, semelhante ao método mostrado em Aumentando o desempenho de consultas lentas com a execução de consultas paralelas por Alexander Rubin. Do jeito que está, vou pegar o id mais alto SELECT id from table_name order by id DESC limit 1e espero que minhas tabelas não fiquem muito fragmentadas.
Um cliente relatou que estava executando no SQL Server 2012 e, no entanto, entregamos algumas consultas de teste para teste antes de uma entrega final:
'CONCAT' não é um nome de função integrado reconhecido.
Eu entendo que CONCAT()é uma nova função interna introduzida no SQL Server 2012, que está tudo bem, no entanto, fui solicitado a reverter minha alteração para tornar este 2008R2 compatível sob o pretexto de "o usuário que executa a consulta pode não tem permissões Transact-SQL para executar." Então, estou apenas provando que o cliente provavelmente tem uma versão diferente do SQL Server instalada no DEV do que no PROD.
Não consigo encontrar nenhuma informação sobre especificamente negar SELECT/EXECUTEpermissões para funções de valor escalar internas, mas é possível e, em caso afirmativo, o usuário ainda recebe o mesmo texto de erro?
Estou trabalhando em um projeto de banco de dados PostgreSQL e estou querendo saber a melhor forma de armazenar carimbos de data/hora.
Usuários em fusos horários diferentes usarão o banco de dados para todas as funções CRUD.
Analisei 2 opções:
timestamp NOT NULL DEFAULT (now() AT TIME ZONE 'UTC')
bigint NOT NULL DEFAULT
Pois timestampeu enviaria uma string que representaria o timestamp exato (UTC) para o momento INSERT.
Pois biginteu armazenaria exatamente a mesma coisa, mas em um formato numérico. (os problemas de fuso horário são tratados antes que o millis seja entregue ao servidor, portanto, sempre o millis em UTC.)
Uma vantagem principal de armazenar a bigintpoderia ser que seria mais fácil armazenar e recuperar, pois passar um timestamp corretamente formatado é mais complexo do que um simples número (millis desde o Unix Epoc).
Minha pergunta é qual deles permitiria o design mais flexível e quais poderiam ser as armadilhas de cada abordagem.
Estou criando um software de contabilidade. Preciso fazer valer a escrituração de partidas dobradas. Eu tenho o problema clássico de uma linha por transação versus duas linhas.
Vamos dar um exemplo e ver como ele seria implementado em ambos os cenários.
Considere conta Cashe conta Rent. Quando pago meu aluguel mensal, transfiro $ 100 da minha Cashconta para minha Rentconta.
Em um sistema de uma linha, essa transação seria armazenada como:
transações
tx_id | posting_date
1 | 23/05/2015
registros_transação
id | tx_id | credit_account | debit_account | amount
1 | 1 | Cash | Rent | 100.00
Em um sistema de duas linhas, eu teria que espelhar o mesmo registro de transação para criar um registro oposto que, uma vez que eu somasse ambos, obteria saldo zero.
transações
tx_id | posting_date
1 | 23/05/2015
registros_transação
id | tx_id | type | account | amount
1 | 1 | credit | Cash | 100.00
2 | 1 | debit | Rent | 100.00
Antes de tudo, gostaria de observar: a razão pela qual tenho ambas as tabelas transactionse transaction_records(em vez de uma tabela) é poder lidar com transações divididas (um caso em que transfiro $ 100 de uma Cashconta para duas ou mais contas diferentes).
No começo, tentei implementar isso com uma linha por transação, mas é difícil calcular o saldo da conta e realmente recuperar os dados.
Estou inclinado para o segundo cenário; no entanto, também tem alguns problemas:
transaction_records- um para crédito e outro para débito, ambos com valor de $ 10.ref_idpara cada par de registros que identificará exclusivamente esses registros como sendo os "lados opostos um do outro" dentro de um contexto de um arquivo tx_id.Qual abordagem é melhor/mais simples?
Para simplificar minha pergunta: quero representar um movimento de fundos da conta A para a conta B. Os dois cenários que dei são designs válidos para armazenar essa transação. Como também apontei, ambos têm contras e prós (primeiro: mais fácil de salvar, mais difícil de recuperar; segundo, o oposto).
Eles podem ter outros prós/contras que eu não identifiquei agora, por isso peço a opinião de pessoas mais experientes.
estamos executando o aplicativo java, em execução há muito tempo, o back-end é o MySQL, atualizado recentemente para o MySQL 5.6. Tudo estava funcionando bem, semana passada começou a receber este erro:
Tempo limite de espera de bloqueio excedido; tente reiniciar a transação
que parece nunca parar de terminar. Não sei o que fazer com esse erro para parar.
Por que está ocorrendo de repente?
Se eu usar um nome de banco de dados com um ponto no SQL Server (2005 ou 2008), algo como "MyApp.Sales", isso causará algum problema?
O título não faz muito sentido, mas não consegui pensar em um título melhor para esse problema.
tenho as seguintes tabelas
Projetos
Clientes
Pagamentos
Quando um usuário entra no sistema, ele terá acesso a um determinado projeto. Agora, quero listar todos os pagamentos desse projeto e deve ser bem fácil:
SELECT FROM payments where id_customer in (SELECT id from customers where id_project = 5)
Minha dúvida é: se não for melhor adicionar uma coluna id_project na tabela de pagamentos assim as consultas ficarão mais fáceis e rápidas.