Perguntas[profiler](dba)

Há uma função com valor de tabela no SQL Profiler que notei que parece "chamar-se várias vezes" .

A definição também não faz nada estranho, é uma consulta com poucos JOINse WHEREcláusula com o método hierarchyidIsDescendantOf

O que esta acontecendo aqui? É apenas alarme falso?

Quais são seus pensamentos?

desde já, obrigado

SQL:BatchStarting

exec sp_executesql N'SELECT * FROM [dbo].[GetPermissionsForUser](@p0)
',N'@p0 uniqueidentifier',@p0='7A2137C1-A7D4-415C-A5B5-F4C2351217C9'

SP: Iniciando e SP: Concluído

SELECT * FROM [dbo].[GetPermissionsForUser](@p0)

Esquema

CREATE TABLE [dbo].[permission_matrix] (
    [Id] [uniqueidentifier] NOT NULL,
    [TargetId] [uniqueidentifier] NULL,
    [Permission] [nvarchar](35) NOT NULL,
    [GroupId] [uniqueidentifier] NULL,
    [Options] [int] NOT NULL,
 CONSTRAINT [PK_permission] PRIMARY KEY CLUSTERED ([Id] ASC)

CREATE TABLE [dbo].[hierarchy](
    [NodeId] [int] IDENTITY(1,1) NOT NULL,
    [EntityId] [uniqueidentifier] NOT NULL,
    [EntityType] [smallint] NOT NULL,
    [ParentEntityId] [uniqueidentifier] NULL,
    [NodePath] [hierarchyid] NOT NULL,
 CONSTRAINT [PK_hierarchy] PRIMARY KEY NONCLUSTERED ([NodeId] ASC)

CREATE FUNCTION [dbo].[GetPermissionsForUser]
(   
    @userId UNIQUEIDENTIFIER
)
RETURNS TABLE 
AS
RETURN 
(
    SELECT
        op.Id,
        op.TargetId,
        op.Permission,
        op.GroupId,
        op.Options
    FROM [dbo].[permission_matrix] op
    WHERE EXISTS(
    SELECT
        1
    FROM [dbo].[hierarchy] gh
    JOIN [dbo].[hierarchy] uh
        ON uh.EntityId = @userId
        AND uh.NodePath.IsDescendantOf(gh.NodePath) = 1 
    WHERE gh.EntityId = op.GroupId)
)

Isto é o que mostra no SQL Profiler

-- Editar

A sessão de evento estendida não exibe isso

Tenho uma coleção simples postscom alguns documentos. Eu configurei o nível de criação de perfil para 2, permitindo que as informações de criação de perfil sejam coletadas em outra coleção system.profile. Meu objetivo é usar uma operação mapReduce para coletar informações da commandentrada agrupada por meio de vários atores usando esta consulta simples:

db.system.profile.mapReduce(
    function()
    {
        emit( this.appName, this.command  );
    },
    function( key, values ) 
    {
        return JSON.stringify(values);
    },
    {
        query: {},
        out  : "command_maps"
    }
)

No entanto, tentar isso no REPL produz o seguinte erro

2021-05-10T22:09:33.494+0800 E QUERY    [js] Error: map reduce failed:{
    "ok" : 0,
    "errmsg" : "rename failed: { ok: 0.0, errmsg: \"error with source namespace: cannot write to 'test.tmp.mr.system.profile_22'\", code: 20, codeName: \"IllegalOperation\" }",
    "code" : 10076,
    "codeName" : "Location10076"
} :
_getErrorWithCode@src/mongo/shell/utils.js:25:13
DBCollection.prototype.mapReduce@src/mongo/shell/collection.js:1145:1
@(shell):1:1

Suspeito que o mongo esteja tentando gravar temporariamentesystem.profile na coleção e falhe devido ao fato de ser somente leitura em certo sentido. Existe alguma maneira de executar isso com sucesso?

Infelizmente, os documentos são muito grandes para serem adicionados aqui, mas basicamente é mais ou menos assim:

DOCUMENTO

{ 
   "appName": "actor1",     
   "command": {"find": {},"ns" : "test.post""} 
}, 
{  "appName": "actor2", 
   "command": { "find": {},"ns" : "test.comments"} 
}
{
   "appName": "actor1",
   "command": { "insert": {},}
}

RESULTADO

{  appName: "actor1": command_maps: '[{command: "find"}, {command:"query"} ...]' } 
{    appName: "actor2": command_maps: '[{command: "find"}...]' } 

Versão: MongoDB shell versão v4.4.5

PS: mapReduce está funcionando corretamente em coleções regulares

Nesta fonte está escrito algo assim

Eu quero saber o que é SQL Trace? Refere-se aqui a Traces dentro do SQL Profiler ou esta é uma ferramenta diferente. Tento pesquisar mas não encontro nenhum recurso. Obrigado

Eu executei um SQL Profiler Trace que detectou um bloqueio de processo. Agora o que devo fazer, se ele sempre traz o mesmo evento de bloqueio, cada vez que a duração é maior. Tenho apenas uma transação que criou um bloco, e quero que ele seja corrigido em um rastreamento apenas uma vez, por que fica repetindo? Obrigado

Quero saber o que é um resultado agregado de um evento e o que fazer para obter resultados agregados?

Obrigado pelo seu tempo!

Quero filtrar um rastreamento e me perguntar o que a caixa de seleção 'excluir linhas que não contêm valores' faz exatamente? É para filtrar todas as colunas de dados que não estão selecionadas em nenhuma classe de evento?

Obrigado.

Estou usando o SQL Profiler no MS SQL Server. Posso filtrar colunas de dados clicando em 'Filtros de coluna'. Mas esse filtro se aplica a todos os eventos. Quero filtrar o login apenas para 2 eventos. Como auditar login e logout apenas para login especificado, mas todos os outros eventos para todos os logins. É possível fazer isso, e como se sim. Obrigado pelo seu tempo!

Tenho a seguinte tabela no meu banco de dados:

create table [dbo].[tb_StatusLog](
[RequestID] [int] not null,
[statusID] [int] not null,
[startTime] [datetime] not null,
[endTime] [datetime] null,
)

com o seguinte índice não agrupado

create nonclusteredindex [index1] on [dbo].[tb_StatusLog]
(
requestID asc, 
statusID asc
)
include ([startTime])

e a seguinte função com valor de tabelafn_getTable

select requestID, max(startTime)
from tb_StatusLog
where statusID=2
group by requestID, statusID

depois de executar o profiler trace e executar os resultados pelo db engine tuning advisor, ele propôs que eu criasse o seguinte índice (que é o mesmo índice que tenho, mas com as colunas de chave invertidas):

create nonclusteredindex [index2] on [dbo].[tb_StatusLog]
(
statusID asc, 
requestID asc
)
include ([startTime])

Agora, ao executar fn_getTable, o plano de execução usa index2em vez de index1e o desempenho é aprimorado.

Por que é que?

Desejo executar o SQL Profiler para consultas de longa execução no SQL Server 2016. Qual é a melhor prática, sem afetar o desempenho do SQL em menos tempo e mais produtivo?

Acabei de executar uma consulta que foi bem rápida e o SQL Profiler disse que usou 30.000 leituras. Agora estou olhando para esta página: https://cloud.google.com/compute/docs/disks/performance e vejo que um disco permanente padrão tem 3.000 IOPS de leitura.

Isso significa que minha consulta levaria 10 segundos quando executada lá? Ou significa SQL readse read IOPSsignifica uma coisa totalmente diferente?