ΩmegaMan's questions

Ao analisar a configuração do Universal Data Link (UDL) da documentação (V2022/2019 e 2016), ela diz que posso usar um arquivo UDL para tentar um Active Directory - Universal with MFA support:login de tipo por meio do menu suspenso ( Seção 2 nas caixas de diálogo abaixo ).

Mas minha versão em uma VM Windows 10 e minha estação de trabalho Windows 11 não têm essa opção. O que eu tenho que fazer, para obter a opção?

À esquerda está (caixa de diálogo do Windows 10/11) À direita está a visualização da documentação.

Estou tentando carregar uma tabela com valores que são gerados aleatoriamente com base em outra tabela. O problema é que o conjunto de resultados do final Cross Join, não é único (aleatório) para cada uma das linhas da tabela final cruzada.

CTE desconstruído

; with MinMax as   -- Step one get the range of values for each `DetailCategoryId`
(
     select distinct DetailCategoryId,
      min(DetailId) over(partition by DetailCategoryId) as [Min] 
    , max(DetailId) over(partition by DetailCategoryId) as [Max]
    from Ref.Detail
)

, RandProcess as   -- Step two pick a random number between the range for each
(
    select MM.DetailCategoryId
      ,   (MM.[Min] + FLOOR(RAND() * (MM.[Max] + 1 - MM.[Min]))) as Rando
    from MinMax MM
)

O passo final é criar uma tabela de referência cruzada Cross JOINque dará o conjunto de RandProcessem cada item. .

select  PRJ.ProjectId, RD.DetailCategoryId, RD.Rando
from info.Project PRJ
CROSS JOIN RandProcess RD

O problema é que cada conjunto de dados na PRJtabela é o mesmo. Aqui estão as duas primeiras linhas de cada conjunto de PRJdados.

10000   101 7
10000   102 10
...
10001   101 7
10001   102 10
...
10002   101 7
10002   102 10

Pergunta

Como posso fazer com que cada um dos conjuntos de PRJs seja diferente (aleatório) para cada uma das linhas do PRJ?

10000   101 7
10000   102 10
...
10001   101 4
10001   102 11
...
10002   101 1
10002   102 14

Por que

Meu objetivo é inserir esses valores em outra tabela como valores de teste para cada um dos PRJelementos de dados.

Qual é a abordagem para conceder a um usuário a capacidade de visualizar todos os procedimentos armazenados em todos os esquemas?

O comando como

GRANT VIEW DEFINITION ON [dbo].[{SprocNameHere}] TO [{UserNameHere}] 

é um pônei de um truque e tem que ser feito para todos os sprocs. Existe uma maneira mais genérica de incluir todos?

Recentemente, codifiquei um procedimento armazenado no SQL Server 2019 (14.0.3192.2) na AWS que utilizou a função STRING_AGGsem problemas. Quando mudei o código para meu banco de dados de teste local, ele reclamou desse método.

Após a pesquisa , continuei a atualizar meu serviço de banco de dados sql server local da versão 14.x para a versão 15.0.2 mais recente e tentei instalar o sproc novamente; ao fracasso

Sintaxe incorreta perto de '"'',STRING_AGG(ActionDATE, ''","''),''"'.

Esse recurso é viável desde o SQL Server 2017... portanto, estar ausente na versão local de 2019 é um pouco intrigante.

Pergunta

Que recurso tenho além de instalar o SQL Server 2019 Developer Edition para resolver esse problema?

Intenção

Observe que a linha de falha com STRING_AGGestá tentando criar uma submatriz JSON de datas, como

[ '01/24/2020', '01/28/2020' ]:

Código

CREATE PROCEDURE [hcwfba].[GetOperationsAndActionDates] 
    @operationId int,
    @locationId int  
AS       

WITH  [DATA] AS (SELECT DISTINCT id_Operation, id_Location , CONVERT(varchar, ActionDATE ,101) AS [ActionDATE] FROM OperationDetail)

SELECT distinct 
         PD.id_Operation
       , PD.id_Location
       , JSON_QUERY((SELECT CONCAT(''["'',STRING_AGG(ActionDATE, ''","''),''"]'') FROM [DATA] DT2 WHERE DT2.id_Location = PD.id_Location)) As Dates
FROM [DATA] PD
WHERE PD.id_Operation = @operationId 
AND PD.id_Location = @locationId
FOR JSON AUTO;

RETURN @@ROWCOUNT 

Resultado JSON

[
    {
        "id_Operation": 13,
        "id_Location": 8675309,
        "Dates": [
            "12/03/2018",
            "08/27/2018",
            "10/22/2018"
        ]
    }
]

Este erro é gerado ao tentar criar uma tabela com uma coluna computada de um Datecampo.

Choque de tipo de operando: int é incompatível com data

Se eu comentar a coluna computada, ela funciona.

[DateInActive][Date] NULL,             -- Date origination
[IsValid] AS (IsNull(DateInActive, 1)) -- Failure here

O pensamento IsValidé simplesmente retornar um biton|off para este campo para significar que nenhuma data inativa foi relatada e, em caso afirmativo, é válida.

A coluna será passada para JSON em uma For JSONsaída como um is-acampo para uso fora do SQL.

SQL completo

CREATE TABLE [history].[PhoneBook](
    [PhoneBookId] [int] IDENTITY(1,1) NOT NULL,
    [PersonId] [int] NOT NULL,
    [PhoneId] [int] NOT NULL,
    [DateActive][Date] NOT NULL,
    [DateInActive][Date] NULL,
    [IsValid] AS (IsNull(DateInActive, 1))
 CONSTRAINT [PK_PhoneBook_1] PRIMARY KEY CLUSTERED 
(
    [PersonId] ASC,
    [PhoneId] ASC

)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, 
       ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY]

Por que isso falha no SQL Developer em um banco de dados Oracle e qual seria a maneira apropriada de alcançar o mesmo?

DECLARE v_pNbr NUMBER := 100150; 
begin
     select * from TARGETTABLE where PROCESSNBR = v_pNbr;
end;

ORA-06550: linha 3, coluna 2: PLS-00428: uma cláusula INTO é esperada nesta instrução SELECT

Vindo do SQL Server, me acostumei a criar variáveis ​​no editor/página de consulta do SSMS e, em seguida, executá-las em várias seleções. Por isso, permite entender as operações com uma mudança para um em vez de muitos. Os exemplos que eu vi parecem sugerir um uso histórico do terminal em vez do editor, o que pode impedir essa maneira de trabalhar.... Portanto, qual é a maneira aceita de trabalhar com pl/sql como tal.

Como alguém faria para ter um sproc que permitisse a um consumidor especificar opcionalmente o número de linhas retornadas?

Se nenhuma contagem de linhas for especificada, todas as linhas serão retornadas.

Ao tentar atingir um Pivotobjetivo -ed para uma tabela de dados de duas linhas em uma linha, meu primeiro pensamento foi usar um arquivo Cross Apply. Usando o Cross Applypode-se identificar/gerar cada uma das linhas com um nome de coluna específico derivado do id exclusivo da linha. (por exemplo, 'Lat1' e 'Lat2 para uma coluna de origem 'Latitude').

Tudo está bem quando eu uso ou INTtipos FLOATde dados, mas quando tento usar um DateTimearquivo .VALUESDateTime

Exemplo Lat/Long/DateTime de Envio

Temos dois pontos em uma viagem de navios relatados em dois dias diferentes:

CREATE TABLE #Shipping
(
     [RouteID]     [INT]  NOT NULL,
     [Latitude]    FLOAT NOT NULL, 
     [Longitude]   FLOAT NOT NULL,
     [Time]        DATETIME NOT NULL

);

INSERT #Shipping(RouteID, [Latitude], [Longitude], [Time])
VALUES          (1,         18.0221,    -63.1206,  '24-Jan-2016'), 
                (2,         17.8353,    -62.99667, '25-Jan-2016');

CrossApply bem-sucedido Se usarmos CrossApplyos dados das três primeiras colunas

  SELECT  col+cast([RouteID] as varchar(1)) new_col
         , X.value
       FROM #Shipping
  CROSS APPLY
  (
      VALUES
         (RouteID,   'Id')
      ,  (Latitude,  'Lat')
      ,  (Longitude, 'Lon')
  ) X (value, col)

Nossos resultados são os esperados:

Excelente!

Falha CrossApply com DateTime

Mas uma vez que adicionamos DateTimeà mistura:

      SELECT  col+cast([RouteID] as varchar(1)) new_col
             , X.value
           FROM #Shipping
      CROSS APPLY
      (
          VALUES
             (RouteID,   'Id')
          ,  (Latitude,  'Lat')
          ,  (Longitude, 'Lon')
          , ([Time],    'Time')
      ) X (value, col)

todos se tornam DateTimes

Como contornar isso se meu objetivo final é dinamizar todos os valores da tabela original em uma linha?

Meu objetivo final é comparar duas linhas (existirão apenas duas) e para um tipo específico e determinar se os valores de suas linhas são maiores que os outros valores de tipo de linha. O resultado que obtive parece ser difícil de manejar, o que me faz pensar se isso pode ser feito de maneira mais rápida ou mais elegante.

Eu criei o sql fiddle aqui que demonstra o problema.

Digamos que estamos transportando carga e nossa rota principal do tipo 1 precisa ser comparada com a outra rota do tipo 2. Cada rota tem um valor Wave e um valor Roll que precisam ser comparados independentemente. Observe que outros tipos de rota (exceto a principal, é sempre usado) podem ser comparados ao Mainvalor do tipo 1, mas apenas dois de cada vez .

CREATE TABLE Shipping
(
[RouteID]         [INT]  NOT NULL,
[WaveValue]       [INT] NOT NULL, 
[RollValue]       [INT] NOT NULL

);

INSERT Shipping(RouteID, WaveValue, RollValue)
VALUES (1, 20, 2),  -- This is the main route
       (2, 10, 30); -- The other secondary route, (only 2 items ever in this table)

Com os valores atualmente na tabela esperamos que a MainsWave seja maior que a outra onda e o inverso para o Roll.

Aqui está o sql de trabalho, observe que o verdadeiro resultado final está preocupado apenas com IsMainWaveGreatere, IsMainRollGreatermas todas as colunas são mostradas para depuração :

   SELECT Max1.RouteID
        , Max1.WaveValue
        , Max1.RollValue
        , MaxOther.RouteID
        , MaxOther.WaveValue
        , MaxOther.RollValue
  , IIF(Max1.RouteID = 1,
        IIF(Max1.WaveValue > MaxOther.WaveValue, 1, 0),
        IIF(Max1.WaveValue > MaxOther.WaveValue, 0, 1)) AS IsMainWaveGreater
  , IIF(Max1.RouteID = 1,
        IIF(Max1.RollValue > MaxOther.RollValue, 1, 0),
        IIF(Max1.RollValue > MaxOther.RollValue, 0, 1)) AS IsMainRollGreater
   FROM
    Shipping AS Max1
   INNER JOIN Shipping AS MaxOther ON Max1.RouteID > MaxOther.RouteID;

Como a linha que pode ser lida primeiro e unida à próxima pode não ser a rota principal ( lembre-se sempre do valor 1 em RouteIDmain ), o sql deve ter um IIFque verifique qual é o tipo Max1 e, em seguida, troque a verificação/resultados de acordo .

Isso pode ser otimizado ou mesmo reescrito?

Esta é apenas uma operação em um processo CTE para que outras operações possam ser realizadas.

Eu criei um envolvido CTE, sem recursão, mas com várias seleções sendo feitas à medida que processa a lógica de negócios do requisito. No entanto, fui informado de que a lógica necessária para o cenário em que nenhuma linha é retornada deve, em vez disso, retornar todas as linhas encontradas em uma das seleções intermediárias CTEem vez da operação final.

Como isso pode ser alcançado?

Observe que o exemplo a seguir é a interpretação básica do meu processo e a operação em questão ocorre depois que várias seleções CTE em cascata são feitas e essencialmente encadeadas.

Exemplo (conforme encontrado em SQLFiddle )

Em uma tabela de usuário, existem dois registros onde os ids de UserIds são 1e 2. O primeiro CTEs select TargetUsersnão retornará nenhuma linha que exija o terceiro CTE, ComputeWithUsers, para usar o AllUsers.

WITH TargetUsers AS
(
  SELECT * 
  FROM Users
  WHERE UserId > 5
)
, AllUsers AS
(
   SELECT * FROM Users
)
, ComputeWithUsers
(
-- This CTE will determine it needs to use `AllUsers` and not `TargetUsers`
)

Ou existe uma maneira de tornar a TargetUsersseleção inteligente o suficiente para extrair todos os usuários quando sua operação principal não retornar nenhuma linha?

Um processo de negócio em SQL pode gerar uma variável a cada operação 1-N número de chamadas a um procedimento armazenado cujo objetivo é inserir dados relacionados ao processo principal.

Como alguém executa várias linhas de sql gerado a partir de uma seleção ou existe uma maneira de chamar um procedimento armazenado a partir de uma seleção?

O processo antes desta etapa é uma operação envolvida de lógica de negócios e operações orientadas a dados e fez inserções subsequentes em tabelas unidas FK relacionadas.

Nesse ponto em que precisa chamar um procedimento armazenado, ele tem dados prontos para serem processados ​​em uma variável de tabela. A etapa (lógica dentro do proc) chamando o proc armazenado é um processo envolvido que faz sentido estar em um proc armazenado e não pode ser copiado para o proc existente.

Exemplo falso de código gerado gerado por Select.

SELECT 'EXEC [sim].[ROI_Save] ' + CONVERT(varchar(6), VSL.PathId)           + ', '
                                + Convert(varchar(6), @ROIResultId)         + ', '
                                + CONVERT(varchar(6), RT.routeTypeResultId) + ', '
                                + CONVERT(varchar(6), RT.ROI_RouteTypeId)   + '; '
FROM  @routeResultIds RT
JOIN sim.ROI_Result_Vehicle VSL ON RT.ROI_Result_VehicleId = VSL.ROI_Result_VehicleId 

Resultados

Alguém concatena os resultados e chama Exec?

O código de trabalho a seguir tem como alvo o SQL-Server 2012 e eu destilei o problema real em um cenário administrável com o exemplo de código mostrado abaixo também apresentado em SQL Fiddle.

Busco feedback sobre as melhores práticas de uso de CTEs e tabelas temporárias e gostaria de saber se o seguinte poderia ser simplificado como tal.

( Observe que isso também foi solicitado na revisão de código ( processo de relatório de inserção de registros de lacunas ) sem respostas até o momento.)

Premissa

Existem duas Tabelas que abrigam eventos com registro de data e hora para Agentes e Gerenciamento. Um relatório será executado na tabela de agentes. Mas dentro da tabela Agente, se houver intervalo(s) de eventos de mais de 5 horas, o relatório resultante deverá ser preenchido a partir da tabela de eventos de gerenciamento para esse intervalo.

Agente

CREATE TABLE AgentInteractions
(
   [Event]      VARCHAR(12) NOT NULL, 
   [Timestamp] [DateTime] NOT NULL
);


INSERT INTO dbo.AgentInteractions( Event, TimeStamp  )
VALUES ( 'Alpha', '24-Jan-2018 3:04:00 PM' ),
       ( 'Beta', '24-Jan-2018 10:04:00 PM' ),  -- Gap 7 hours
       ( 'Omega', '25-Jan-2018 2:04:00 AM' );  -- No Gap

Gestão

CREATE TABLE ManagementInteractions
(
  [Event]      VARCHAR(12) NOT NULL, 
  [Timestamp] [DateTime] NOT NULL
);


INSERT INTO dbo.ManagementInteractions( Event, TimeStamp  )
VALUES ( '5pm',      '24-Jan-2018 5:00:00 PM' ),  -- Gap Filler #1
       ( '8pm',      '24-Jan-2018 8:00:00 PM' ),  -- Gap Filler #2
       ( 'Midnight', '25-Jan-2018 12:00:00 AM' ); -- Not used

Relatório inicial (ou primeira etapa)

Com o seguinte sql que coloca o relatório na tabela temporária, ele calcula a diferença de tempo entre as linhas e configura uma sequência que não estava presente nos dados de origem.

CTE para tabela temporária

IF OBJECT_ID('tempdb..#Actions') IS NOT NULL DROP TABLE #Actions;

WITH AgentActions AS 
( SELECT  ROW_NUMBER() OVER ( ORDER BY [Timestamp] ) AS [Sequence], -- Create an index number ordered by time.
          Event ,
          Timestamp
  FROM  AgentInteractions
)
SELECT  CAST('Agent' AS VARCHAR(20)) AS [Origin] ,
            AgentActions.Sequence ,
            AgentActions.Event ,
            ( SELECT    Other.Timestamp
              FROM      AgentActions Other
              WHERE     Other.Sequence = AgentActions.Sequence - 1
            ) AS Previous ,
            AgentActions.Timestamp ,
            ISNULL(DATEDIFF(HOUR,
                            ( SELECT    Other.Timestamp
                              FROM      AgentActions Other
                              WHERE     Other.Sequence = AgentActions.Sequence - 1), 
                            AgentActions.Timestamp), 
                            0) AS TimeFromLastPoint
    INTO    #Actions
    FROM    AgentActions;

Resultado de um select into #Actions, observe o intervalo de 7 horas:

Determinar lacunas

O sql a seguir determina as lacunas e insere os registros da tabela de gerenciamento que preenchem a lacuna.

Inserir eventos de gerenciamento nas lacunas

WITH Gaps AS 
( SELECT   AC.Origin ,
           AC.Sequence ,
           AC.Event ,
           AC.Previous ,
           AC.Timestamp ,
           AC.TimeFromLastPoint
  FROM     #Actions AC
  WHERE    AC.TimeFromLastPoint > 5
)
INSERT  INTO #Actions ( [Origin] , [Event] , [Timestamp] , TimeFromLastPoint)
            SELECT  'Management' ,
                    [Event] ,
                    [Timestamp] ,
                    0                      -- We will figure this out after the insert.
            FROM    ManagementInteractions MAN
            WHERE   EXISTS ( SELECT *
                             FROM   Gaps
                             WHERE  MAN.Timestamp BETWEEN Gaps.Previous
                                                  AND     Gaps.Timestamp );

SELECT Origin , Sequence , Event , Previous , Timestamp , TimeFromLastPoint 
FROM #Actions ORDER BY Timestamp;

Resultado da seleção.

Relatório final

O relatório final faz o que foi feito na etapa 1, ele resequencia e determina as durações de tempo entre todos os pontos.

CTE Deja-vu Relatório Final

WITH Combined AS 
( 
   SELECT Origin,
          ROW_NUMBER() OVER ( ORDER BY [Timestamp] ) AS [Sequence], -- Create an index number ordered by time.
          Event ,
          Timestamp
    FROM  #Actions
)
SELECT  Combined.Origin,
        Combined.Sequence ,
        Combined.Event ,
        ( SELECT    Other.Timestamp
          FROM      Combined Other
          WHERE     Other.Sequence = Combined.Sequence - 1
        ) AS Previous ,
        Combined.Timestamp ,
        ISNULL(DATEDIFF(HOUR,
                        ( SELECT    Other.Timestamp
                          FROM      Combined Other
                          WHERE     Other.Sequence = Combined.Sequence
                                    - 1
                        ), Combined.Timestamp), 0) AS TimeFromLastPoint

FROM  Combined;

Aqui estão os resultados

Resumo

Alguma das etapas pode ser combinada ou há alguma prática que devo usar ou evitar com o código sql acima?

Qual seria a fórmula para calcular uma coluna de bits a partir de outras colunas de bits?

Por exemplo:

CREATE TABLE #Employee
(
[empNumb]       [INT] identity(1,1) PRIMARY KEY,
[IsOk]          [BIT] NOT NULL, -- This is computed from other three columns.
[HasValidHours] [BIT] NOT NULL,
[NoDemerits]    [BIT] NOT NULL,
[NoAccidents]   [BIT] NOT NULL
);

ALTER TABLE #Employee ADD CONSTRAINT [DF_Employee_HasValidHours]  
  DEFAULT ((0)) FOR [HasValidHours];
ALTER TABLE #Employee ADD CONSTRAINT [DF_Employee_NoDemerits]  
  DEFAULT ((0)) FOR [NoDemerits];
ALTER TABLE #Employee ADD CONSTRAINT [DF_Employee_NoAccidents]  
  DEFAULT ((0)) FOR [NoAccidents];

IsOkseria calculado a partir do e -ing de HasValidHours, NoDemeritse NoAccidents.