Eric S's questions

Recebo essa mensagem de erro ocasionalmente quando executo um procedimento armazenado que extrai informações de vários servidores vinculados e agrega os dados. Parece com o que tenho abaixo.

DECLARE Cur CURSOR FOR SELECT name FROM sys.servers WHERE is_linked = 1 AND (@Environments IS NULL OR name IN (SELECT Item FROM clrStringSplit(@Environments, ',')))
OPEN cur
FETCH NEXT FROM cur INTO @Environment
WHILE @@FETCH_STATUS = 0
BEGIN
BEGIN TRY   

    SET @Query = '          
        EXEC ' + @Environment + '.db.dashboard.storedproc ''' + CAST(@StartDate AS VARCHAR(10)) + ''', ''' + CAST(@EndDate AS VARCHAR(10)) + ''''

    INSERT INTO #Table (Environment, Column1, Column2, Column3, Column4, Column5, Column6, Column7)
    EXEC(@Query)
END TRY
BEGIN CATCH
    PRINT 'There was an error trying to query against ' + @Environment
    PRINT ERROR_MESSAGE() 
END CATCH

FETCH NEXT FROM cur INTO @Environment
END

O procedimento armazenado que ele chama em cada servidor é exatamente o mesmo em cada um e é uma instrução select básica que extrai das tabelas sob o esquema dbo. O erro "aleatoriamente" será exibido com a mensagem "Não foi possível concluir a operação do cursor porque o esquema da tabela foi alterado após a declaração do cursor". Às vezes corre bem, outras não. Cada vez que é executado, mesmo que de volta para trás, às vezes funciona e às vezes não. O que poderia causar isso e por que é tão intermitente? O erro pode ser gerado em qualquer chamada para um procedimento em um dos servidores. Nem sempre é o mesmo servidor que ele tenta consultar que produz o erro.

Vale a pena mencionar que tenho vários procedimentos de todos os que fazem algo extremamente semelhante, mas nunca produzem o problema. Mas eles estão todos sob o mesmo esquema (dbo) e esta é a primeira vez que um esquema diferente é usado.

EDIT - esqueci de mencionar que tentei usar um cursor FAST_FORWARD e não parece ajudar.

Eu corri para uma consulta hoje que fez algo que eu não tinha visto antes. Fez algo assim:

SELECT 
    MIN(+ - schema_id) AS [WhatInTheWorld?], 
    MIN(schema_id) AS MinimumID, 
    MAX(+ - schema_id) AS [Uhhh], 
    MAX(schema_id) AS MaxID
FROM sys.objects

O que dá os seguintes resultados:

WhatInTheWorld? MinimumID    Uhhh       MaxID
-4              1            -1         4

O que exatamente o "+" e o "-" estão fazendo?

Tenho uma estrutura simples em que não tenho certeza de como lidar com alguns dos problemas que surgem.

Existem 4 tabelas: Reports, ReportParameters, ScheduledReports, ScheduledReportParameters.

ReportParameterslista os parâmetros necessários para os relatórios.

ScheduledReportsé uma instância agendada de um relatório. (Relatório X a ser executado na quinta-feira como exemplo).

ScheduledReportParametersé a lista de parâmetros e seus valores a serem usados ​​quando esta instância for executada.

Disposição básica:

Reports:
ReportID (PK)

ReportParameters:
ReportParameterID (PK)
ReportID (FK to Reports)
Name

ScheduledReports:
ScheduledReportID (PK)
ReportID (FK to reports)

ScheduledReportParameters:
ScheduledReportID (FK to ScheduledReports)
ReportParameterID (FK to ReportParameters)
Value
(PK is formed by the ScheduledReportID and ReportParameterID)

Isso tem o problema em que o parâmetro associado a um relatório agendado não precisa concordar com o que o relatório base realmente espera, pode ser um relatório base totalmente diferente e não o relatório no qual o relatório agendado se baseia.

Então, pensei que poderia adicionar o ReportIDao ao ScheduledReportParameters, mas isso não ajuda, pois não haveria nada obrigando que o ReportIDlá concordasse com o que o ScheduledReporté baseado.

Estou perdendo algo simples? Ou isso é mais complicado do que eu pensava?

Ter um relatório agendado com parâmetros que na verdade não acompanham o relatório não é um grande problema para mim, pois quando eu os puxo, as junções filtrarão automaticamente quaisquer possíveis erros, mas eu gostaria de evitar que dados ruins entrem no primeiro lugar. Eu sei que poderia usar gatilhos para fazer isso, mas isso pode ficar feio rapidamente.

Criei uma função que pega uma string e retorna uma tabela com a posição e caractere de cada letra da string. No entanto, como a recursão CTE é limitada a 100 níveis, ela falha se uma string passada for maior que isso. Sei que posso usar OPTION (MAXRECURSION [value])para alterar o limite, mas isso não parece funcionar na hora de definir a função.

minha função:

CREATE FUNCTION [dbo].[StringSplit]
(
    @String NVARCHAR(MAX)    
)
RETURNS TABLE
AS
RETURN
(   
    WITH Split(Pos,Digit)
    AS(
        SELECT 1 AS Pos, LEFT(@String, 1) AS Digit
        UNION ALL
        SELECT Pos + 1, RIGHT(LEFT(@String, Pos + 1), 1)
            FROM Split
            WHERE Pos < LEN(@String)
    )
    SELECT Pos, Digit FROM Split    
    ---OPTION (MAXRECURSION 0) -- Unable to create function if this line is UnCommented)
)

Assim, o seguinte código sql falhará devido a atingir o limite padrão de 100:

SELECT * FROM Impact_Work.dbo.StringSplit('How long of a sentence can I possibly think of for testing thingymadoodlers out. Yes I do love the word thingymadoodlers so don''t judge me!')

Agora, se eu adicionar a opção, funcionará

SELECT * FROM Impact_Work.dbo.StringSplit('How long of a sentence can I possibly think of for testing thingymadoodlers out. Yes I do love the word thingymadoodlers so don''t judge me!')
OPTION (MAXRECURSION 0)

No entanto, é altamente improvável que aqueles que usam essa função se lembrem de adicionar esse bit extra às suas consultas, portanto, espero adicioná-lo à própria função. Isso é possível? (E sim, eu divago loucamente quando preciso criar alguma string para teste)

Eu tenho uma tabela que contém uma coluna id, uma coluna pai e uma coluna filho. Então, para cada registro, eu sei qual registro vem antes dele e o que virá depois dele em um relacionamento em cadeia, mas do registro individual, não sei em que posição está dentro da cadeia nem qual é a primeira parte ou a última parte de a corrente.

Para fins de demonstração, suponha que temos a seguinte configuração. Percebo que há muitos problemas de design com esse tipo de configuração, mas é com isso que tenho que trabalhar.

CREATE TABLE Relationships (
ID VARCHAR(4), 
ParentID VARCHAR(4),
ChildID VARCHAR(4)
)

-- Insert root entries with their children
INSERT INTO Relationships (ID, ParentID, ChildID)
VALUES ('0001', '', '0003'), ('0002', '', '0004')

-- Now add further entries for each relationship chain
INSERT INTO Relationships(ID, ParentID, ChildID)
VALUES('0003', '0001', '0005'), ('0005', '0003', '0006'), ('0006', '0005', '0007'), ('0007', '0006', ''), 
  ('0004', '0002', '')

--Now we have two chains of 0001 -> 0003 -> 0005 -> 0006 -> 0007 and 0002 ->   0004

Com um CTE recursivo como abaixo, posso descobrir como todos os registros estão relacionados em sua cadeia e sua posição dentro da cadeia.

WITH RelationshipChain AS (
SELECT ID, ParentID, ChildID, 0 AS Seq, ID AS RootID
FROM Relationships WHERE ParentID = ''
UNION ALL
SELECT r2.ID, r2.ParentID, r2.ChildID, rc.Seq + 1 AS Seq, rc.RootID AS RootID
FROM Relationships r2 
INNER JOIN RelationshipChain rc ON rc.ChildID = r2.ID 
)

SELECT * FROM RelationshipChain
ORDER BY RootID, Seq

Para cerca de 2 milhões de registros, isso é executado em cerca de 30 segundos, o que é muito bom; no entanto, se eu tentar incluir também a parte final da cadeia, levará 4 vezes mais tempo para ser executado. Atualmente, estou fazendo assim:

WITH RelationshipChain AS (
SELECT ID, ParentID, ChildID, 0 AS Seq, ID AS RootID
FROM Relationships WHERE ParentID = ''
UNION ALL
SELECT r2.ID, r2.ParentID, r2.ChildID, rc.Seq + 1 AS Seq, rc.RootID AS RootID
FROM Relationships r2 
INNER JOIN RelationshipChain rc ON rc.ChildID = r2.ID 
)

SELECT * 
FROM RelationshipChain rc
CROSS APPLY (
SELECT MAX(Seq) AS FinalSeq FROM RelationshipChain WHERE rc.RootID = RootID
) AS b
CROSS APPLY (
SELECT ID AS LastChild FROM RelationshipChain WHERE b.FinalSeq = seq AND rc.RootID = RootID
) AS c
ORDER BY RootID, Seq

Existe uma maneira de fazer isso de forma mais eficiente?

Estou tentando encontrar uma maneira de executar um trabalho de manutenção a partir do script e retorná-lo se o trabalho foi bem-sucedido ou não. Eu sei que posso usar msdb.dbo.sp_start_job para executar o trabalho de manutenção, mas ele só iniciará sem retornar se foi bem-sucedido ou não.

Meu objetivo final para isso é usar o JAMS para todo o nosso agendamento de trabalho e queremos apenas verificar se há falhas no trabalho.