user960567's questions

Acabei de restaurar meu banco de dados usando o script abaixo,

USE [master]
GO
RESTORE DATABASE [MyDB] 
FROM  DISK = N'C:\Program Files\Microsoft SQL Server\MSSQL14.SQLSTANDARD\MSSQL\Backup\mydb.bak' WITH  FILE = 1, 
NOUNLOAD,  REPLACE,  STATS = 5, KEEP_CDC
GO


USE MyDB
GO
EXECUTE sys.sp_cdc_add_job 'capture';
GO
EXECUTE sys.sp_cdc_add_job 'cleanup';
GO

Então verifiquei o CDC,

select is_tracked_by_cdc,name from sys.tables order by is_tracked_by_cdc desc
select is_cdc_enabled,name from sys.databases order by is_cdc_enabled desc

CDC habilitado para minhas tabelas. Então executei o script UPDATE,

UPDATE MyTable SET Name='SomeName' where id=1

Mas não encontrei nenhum registro na tabela cdc,

SELECT * FROM [cdc].[dbo_MyTable_CT]

Instalei a atualização cumulativa mais recente (CU31).

Estou executando esta consulta,

SELECT name
, snapshot_isolation_state
, is_read_committed_snapshot_on
FROM sys.databases s

name        snapshot_isolation_state    is_read_committed_snapshot_on
master        1                               0
tempdb        0                               0
model         0                               0
msdb          1                               0
MyDB1         1                               1
MyDB2         1                               1

MyDB1 e MyDB2 estão habilitados para instantâneo, mas ainda todas as minhas consultas do Entity Framework estão usando,

select transaction_isolation_level from sys.dm_exec_requests

Todos os valores das sessões são transaction_isolation_level=2o que significa Read Committed. O que posso fazer?

Estou usando o driver ODBC para transferir dados do Postgres para o SQL Server https://learn.microsoft.com/en-us/sql/integration-services/import-export-data/connect-to-a-postgresql-data-source -sql-server-import-and-export-wizard?view=sql-server-ver16

O problema é que algumas tabelas estão jogando,

Erro 0xc0047062: Tarefa de fluxo de dados 1: System.Data.Odbc.OdbcException (0x80131937): ERRO [57014] ERRO: cancelamento da instrução devido ao tempo limite da instrução; Erro ao executar a consulta em System.Data.Odbc.OdbcConnection.HandleError(OdbcHandle hrHandle, RetCode retcode) em System.Data.Odbc.OdbcCommand.ExecuteReaderObject(CommandBehavior behavior, String method, Boolean needReader, Object[] methodArguments, SQL_API odbcApiMethod) em System.Data.Odbc.OdbcCommand.ExecuteReaderObject(comportamento CommandBehavior, método String, Boolean needReader) em System.Data.Odbc.OdbcCommand.ExecuteReader(comportamento CommandBehavior)
em System.Data.Odbc.OdbcCommand.ExecuteDbDataReader(comportamento CommandBehavior) em System.Data.Common.DbCommand.System.Data.IDbCommand.ExecuteReader(comportamento CommandBehavior) em Microsoft.SqlServer.Dts.Pipeline.DataReaderSourceAdapter.PreExecute() em Microsoft .SqlServer.Dts.Pipeline.ManagedComponentHost.HostPreExecute(IDTSManagedComponentWrapper100 wrapper) (Assistente de importação e exportação do SQL Server)

Estou recebendo este erro após 30 segundos. Aumentei o statement_timeout no postgres e defini Command Timeoutna string de conexão, mas não ajudou. Existe uma maneira de aumentar OdbcCommand.CommandTimeout ao usar o recurso SQL Server Import?

Eu tenho tabelas (mais de 100) que estão faltando chaves primárias. Na verdade, essas são tabelas herdadas. Agora, de acordo com alguns requisitos de replicação, precisamos adicionar a chave primária em cada uma dessas tabelas. Existe alguma maneira de descobrir possíveis chaves primárias em uma mesa (pronta para comprar um produto comercial)?

Atualmente no meu servidor de banco de dados é muito lento. Corrida,

EXEC sp_WhoIsActive
    @find_block_leaders = 1,
    @sort_order = '[blocked_session_count] DESC'

Às vezes ficamos abaixo do erro,

Msg 530, Level 16, State 1, Procedure sp_WhoIsActive, Line 4316 [Batch Start Line 17]
The statement terminated. The maximum recursion 100 has been exhausted before statement completion.

e quando é executado, block_session_count para um número maior, mas blocking_session_id é NULL. Algo está bloqueando e não consigo descobrir.

Também correndo,

SELECT COUNT(*),log_reuse_wait_desc FROM master.sys.databases group by log_reuse_wait_desc

retorna | 60 | LOG_BACKUP|

Quando faço failover, ele começa a funcionar, mas não posso continuar fazendo failover.

Sempre que em nosso sistema há um bloqueio (tudo parado). Vejo que a consulta abaixo é a culpada,

  (@P1 numeric(10))SELECT "Col1128","Tbl1029"."A_NAME" "Col1124" FROM "DbName"."Schema"."MyTable1" 
"Tbl1029" RIGHT OUTER JOIN (SELECT "Tbl1027"."MyColumn1" "Col1126","Tbl1027"."MyColumn2" 
"Col1127","Tbl1027"."MyColumn4" "Col1128","Tbl1027"."MyColumn5" "Col1130","Tbl1027"."MyColumn6" 
"Col1129","Tbl1027"."MyColumn5" "Col1131" FROM "DbName"."Schame"."MyTable2" "Tbl1027" WHERE 
"Tbl1027"."MyColumn1"=@P1) Qry1132 ON CONVERT(numeric(2,0),"Tbl1029"."MyColumn3",0)="Col1126"

Temos 2 servidores de banco de dados separados com bancos de dados completamente diferentes. O acima está sendo executado no servidor de banco de dados 2, mas a solicitação está chegando ao servidor de banco de dados 1 (nome do host do cliente). Temos 100 aplicativos conectados a servidores de banco de dados. Além disso, temos servidor de link entre servidores de banco de dados.

Agora, eu sei que a consulta veio do servidor DB 1 com ProgramName Microsoft SQL Server. Agora estou confuso se o programa Microsoft SQL Serverestá indicando a consulta do servidor de link ou a consulta do aplicativo usando ORM.

Estou procurando em todos os aplicativos, mas não encontrei nada ainda. Forme a perspectiva do DBA, o que mais posso fazer para obter o problema real

Eu tenho uma tabela T simples que tem Col1, Col2, Col3 e Col4. colunas. Col1 é a chave primária. Agora estou executando algum código simultâneo,

Parallel.For(0, list.Count, new ParallelOptions { MaxDegreeOfParallelism = -1 }, j =>
{
   var obj= list[j];
   // Do some work
   // UPDATE T SET Col2, Col3, Col4 WHERE Col1 =@Col1

Cada valor de col1 é diferente. Mas quando executo este código, estou recebendo muitos deadlocks. Como Col1 é PK (índice clusterizado), agora estou confuso por que isso está acontecendo?

No impasse vitim. Vejo Modo Proprietário: U

Sempre que corro,

USE master
GO
DROP TABLE temp_sp_who2
GO
CREATE TABLE temp_sp_who2 ( SPID INT, Status VARCHAR(1000) NULL, Login SYSNAME NULL, HostName SYSNAME NULL, BlkBy SYSNAME NULL,DBName SYSNAME NULL,Command VARCHAR(1000) NULL, CPUTime INT NULL,DiskIO BIGINT NULL,  LastBatch VARCHAR(1000) NULL, ProgramName VARCHAR(1000) NULL,SPID2 INT , RequestId INT NULL )
GO

INSERT  INTO temp_sp_who2
EXEC sp_who2

SELECT  BlkBy ,count(*) FROM 
temp_sp_who2 WHERE CAST(BlkBy AS NVARCHAR(MAX)) <> CAST(SPID AS NVARCHAR(MAX)) 
GROUP By BlkBy
ORDER BY Count(*) DESC
GO

Vejo que BlkBy é diferente com números altos. Mas BlkBy é sempre alto quando o aplicativo está em execução.

Temos execuções/min é muito alto, em torno de 20.000 a 30.000 para uma consulta. Isso significa que a consulta está executando 20.000 por minuto? Não acho que tenhamos tanta carga no servidor que uma única consulta execute 20.000 por minuto.

Além disso, estou sempre confuso com CPU ms/sec. Isso significa CPU total usada por segundo? Se sim, como é que temos muitas consultas com mais de 1000 CPU ms/sec, pois temos CPU limitada no servidor.

Eu tenho Applications, Roles, Users, Permissions, Application_Permissions, User_Permissions, Role_Permissions, Application_Roles e Role_Permissions tabelas. Assim, a permissão pode ser definida em nível de aplicativo, nível de função e nível de usuário. Digamos que User Apertence a Application Xe Application Xpode ter XX Permission. Então, User Avai conseguir XX Permission. Agora, quero dar a todos os usuários Application Bcom XX Permissionmas exceto User B. Como posso encaixar isso no meu design atual?

CREATE TABLE APPLICATION_PERMISIONS (APPLICATION_PERMISION_ID number(15) GENERATED AS IDENTITY, APPLICATION_ID number(15), PERMISION_DEFINITION_ID number(15)CONSTRAINT PK_SEC_APPLICATION_PERMISIONS PRIMARY KEY (APPLICATION_PERMISION_ID));
CREATE TABLE APPLICATION_ROLES (APPLICATION_ROLE_ID number(15) GENERATED AS IDENTITY, APPLICATION_ID number(15), ROLE_ID number(15)CONSTRAINT PK_SEC_APPLICATION_ROLES PRIMARY KEY (APPLICATION_ROLE_ID));
CREATE TABLE APPLICATIONS (APPLICATION_ID number(15) GENERATED AS IDENTITY, CODE varchar2(30), NAME_AR varchar2(255), NAME_EN varchar2(255), START_DATE date, END_DATE date CONSTRAINT PK_SEC_APPLICATIONS PRIMARY KEY (APPLICATION_ID));
CREATE TABLE PERMISION_DEFINITIONS (PERMISION_DEFINITION_ID number(15) GENERATED AS IDENTITY, CODE varchar2(30), NAME_AR varchar2(255), NAME_EN varchar2(255), START_DATE date, END_DATE date CONSTRAINT PK_SEC_PERMISION_DEFITIONS PRIMARY KEY (PERMISION_DEFINITION_ID));
CREATE TABLE ROLE_PERMISSIONS (ROLE_PERMISSION_ID number(15) GENERATED AS IDENTITY, ROLE_ID number(15), PERMISION_DEFINITION_ID number(15), START_DATE date, END_DATE date CONSTRAINT PK_SEC_ROLE_PERMISSIONS PRIMARY KEY (ROLE_PERMISSION_ID));
CREATE TABLE ROLES (ROLE_ID number(15) GENERATED AS IDENTITY, CODE varchar2(30) NOT NULL, NAME_AR varchar2(255), NAME_EN varchar2(255), START_DATE date, END_DATE date CONSTRAINT PK_SEC_ROLES PRIMARY KEY (ROLE_ID));
CREATE TABLE USER_PERMISSIONS (USER_PERMISSION_ID number(15) GENERATED AS IDENTITY, USER_ID number(15), PERMISION_DEFINITION_ID number(15)CONSTRAINT PK_SEC_USER_PERMISSIONS PRIMARY KEY (USER_PERMISSION_ID));
CREATE TABLE USER_ROLES (USER_ROLE_ID number(15) GENERATED AS IDENTITY, USER_ID number(15), ROLE_ID number(15)CONSTRAINT PK_SEC_USER_ROLES PRIMARY KEY (USER_ROLE_ID));

Nosso aplicativo parou de funcionar repentinamente devido a The transaction log for database 'tempdb' is full due to 'ACTIVE_TRANSACTION'.. Agora, ele começa a funcionar novamente. Mas como posso saber o motivo exato para esse erro ter surgido?

Estou tentando entender as consultas caras ativas e as consultas caras recentes no Activity Monitor. O que é caro significa aqui? Isso significa caro em termos de CPU, bloco, memória, leituras?

Estou usando consultas diferentes para encontrar a consulta de bloqueio. Por exemplo,

select
       ec.session_id,
       er.blocking_session_id,
       datediff(s, es.last_request_start_time, GETDATE()) as elapsed_time_sec,
       er.command,
       es.login_name,
       es.host_name,
       es.host_process_id,
       DB_NAME(er.database_id) as database_name,
       esql.text AS batch_text,
       ISNULL(CASE er.statement_end_offset + er.statement_start_offset
             WHEN 0 THEN esql.text 
             ELSE SUBSTRING(esql.text,
                          (er.statement_start_offset/2)+1, 
                          ((CASE er.statement_end_offset
                                       WHEN -1 THEN DATALENGTH(esql.text)
                                       ELSE er.statement_end_offset
                            END - er.statement_start_offset)/2) + 1)
       END, '')
       AS statement_text,
       eplan.query_plan,
       es.program_name,
       es.host_process_id,
       es.last_request_start_time,
       es.last_request_end_time,
       ec.num_reads as num_reads_connection,
       ec.num_writes as num_writes_connection,
       es.reads as reads_session,
       es.writes as writes_session,
       es.logical_reads,
       es.transaction_isolation_level,
       es.row_count,
       er.wait_type,
       er.wait_time
from 
       sys.dm_exec_connections ec
       left join sys.dm_exec_sessions es on ec.session_id = es.session_id
       left join sys.dm_exec_requests er on ec.session_id = er.session_id
       --left join sys.dm_exec_sessions es_blocking on es.session_id = er.blocking_session_id
       outer apply sys.dm_exec_sql_text(er.sql_handle) esql
       outer apply sys.dm_exec_query_plan(er.plan_handle) eplan
where es.status <> 'sleeping'
order by ec.session_id

Aqui estou primeiro verificando linhas com blocking_session_id não é nulo. Então, a partir deste blocking_session_id, encontrá-lo também é bloqueado por outros e assim por diante. Então, digamos que eu tenha,

| -------------------- |
| Spid | Blokcing_Spid |
| -------------------- |
| 1 | 2 |
| 2 | 3 | 
| 3 | 4 | 
| 4 | NULL | 

Aqui 4 é o culpado. Como posso encontrar rapidamente os spids culpados?

Eu tenho executado o DB de produção que normalmente tem 50-100 inserts por minuto. Estou tentando adicionar uma nova coluna no banco de dados de produção usando,

ALTER TABLE MyDB ADD [MyColumn] varchar(30)
GO

Esta consulta continua em execução e não termina até que eu a interrompa. O que mais posso fazer?

Em primeiro lugar, não sou DBA, mas tenho que realizar alguns trabalhos de DBA. Estou tentando ler um arquivo estendido usando,

  SELECT [object_name],[event_data],[file_name],[file_offset],[Event_Time] 
  FROM OPENQUERY(MyServer,'master.dbo.READ_AUDIT @P_RootFile_Name=''Path\DDL*.xel'',@P_File_Name=''Path\file.xel'',@P_Offsit=0')

Estou recebendo este erro,

The offset 0 is invalid for log file .xel  Specify an offset that exists in the log file

Como calculo o deslocamento de um arquivo xel?

ALTER proc [dbo].[READ_AUDIT] @P_RootFile_Name NvarChar(260),@P_File_Name NvarChar(260)=NULL,@P_Offsit bigint =NULL
as

Select * from 
(
select *,



DATEADD(mi, DATEDIFF(mi, GETUTCDATE(), GETDATE()), CONVERT (XML, event_data).value('(/event/@timestamp)[1]', 'datetime2')) Event_Time
from sys.fn_xe_file_target_read_file(@P_RootFile_Name, null, @P_File_Name, @P_Offsit) 



) as T



order by T.Event_Time ASC

Temos uma mesa,

CREATE TABLE [dbo].[MyTable](
    [MasterKey] [uniqueidentifier] NOT NULL,
    [DetailKey] [varchar](100) NULL,
    [JSON] [nvarchar](max) NOT NULL
) ON [PRIMARY] TEXTIMAGE_ON [PRIMARY]
GO

CREATE NONCLUSTERED INDEX [ix_MyTable_details] ON [dbo].[MyTable]
(
    [MasterKey] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, SORT_IN_TEMPDB = OFF, DROP_EXISTING = OFF, ONLINE = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
GO

E temos a consulta abaixo que está causando muitos deadlocks/blocks.

IF EXISTS(SELECT 1 from  [MyTable](nolock) where  [MasterKey]= @MasterKey AND [DetailKey] =  @DetailKey)
BEGIN

 UPDATE [MyTable]
           SET [JSON] = @JSON
    WHERE  [MasterKey]= @MasterKey AND [DetailKey] =  @DetailKey
END
ELSE
BEGIN
INSERT INTO [MyTable]
           ([MasterKey]
           ,[DetailKey]
           ,[JSON])
     VALUES
           (@MasterKey
           ,@DetailKey
           ,@JSON)
END

Observe que um usuário diferente usa a tecla MasterKey ao mesmo tempo, mas no momento da espiada, vemos que o aplicativo não responde. Quando vemos os logs encontramos muitos bloqueios/deadlocks. Também vemos bloqueios Sch-S nesta tabela.

A adição de MasterKey e DetailKey como chave primária pode corrigir esse problema ou o que podemos fazer?

Observe que às vezes o tamanho do JSON é enorme porque inclui imagens como base64.

Temos um banco de dados em torno de terabytes de dados. Estamos fazendo backup COMPLETO toda semana, backup diferencial diário e backup de log de transações a cada hora. Às vezes, esse backup do log de transações leva algum tempo para ser concluído (cerca de 10 a 15 minutos). Neste período descobrimos que o desempenho de aplicativos afeta muito (normalmente muito lento) que usam o mesmo banco de dados.

O backup do log de transações afeta o desempenho do aplicativo? Se sim, como acelerar o processo de backup do log de transações?

Estamos investigando alguns problemas com nosso banco de dados de produção onde alguns registros suspeitos foram inseridos/atualizados em nosso banco de dados. Eu só quero saber como seremos capazes de executar essas instruções TSQL em um determinado momento. Somos o SQL Server 2014 com opção de recuperação COMPLETA.

Desculpe minha ignorância (não sou DBA e não temos nenhum).

Digamos que eu tenha uma pergunta,

SELECT * FROM MyTable WHERE MyParam = 0 OR MyColumn = MyParam

Aqui MyParam é parâmetro e opcional. Então, ele só verifica MyColumn = MyParamse MyParam não é 0. Mas nosso DBA está dizendo que OR fará com que ele fique lento e o db sofrerá. Outra opção é,

IF MyParam = 0 
SELECT * FROM MyTable WHERE MyColumn = MyParam

O problema com essa abordagem é que temos muitos parâmetros opcionais. Então, nossa consulta se tornou muito, muito grande. Outra opção é CASE.

Então o que vocês sugerem. Estou falando em geral se Oracle ou SQL Server.

Temos consultas em procedures no oracle como,

    SELECT  ......
    WHERE   .....
    AND (SomeColumn IS NULL OR SomeColumn = SomeThing)

Mas nosso DBA está dizendo que isso não é bom e dizendo para usar NVL. Estamos usando isso há muito tempo e não encontramos nenhum problema. Devemos trocar IS NULL por NVL? de NVL quero dizerNVL(SomeColumn, '') = SomeThing

Eu tenho uma tabela com milhões de linhas. Esta tabela tem uma coluna que filtramos com frequência (significa que a usamos na cláusula WHERE com frequência), os valores são Inserir/Atualizar/Ignorado. Faz sentido adicionar índice às colunas? Alguém me disse que adicionar índice na coluna de poucos valores não traz nenhum benefício