All perguntas(dba)

Tenho a tarefa de incrementar a coluna do sinalizador esperado examinando os valores existentes. Resolvi isso usando o loop while e posso atualizar o valor esperado usando o loop while no Azure Synapse-Sql Data Warehouse. Mas eu gostaria de saber uma maneira direta de fazer isso usando alguma função de classificação?

Meus dados de amostra

CREATE TABLE [dbo].[work_table](
[work_order_key] [int] NULL,
[modification_date] [datetime2](7) NULL,
[from_status] [varchar](1000) NULL,
[to_status] [varchar](100) NULL,
[count] [int] NULL,
[sequence] [int] NULL,
[count_VCR] [int] NULL,
[flag] [int] NULL,
[flag_expected] [int] NULL
  )

  INSERT [dbo].[work_table] ([work_order_key], [modification_date], [from_status], [to_status], [count], [sequence], [count_VCR], [flag], [flag_expected]) VALUES (1002586, CAST(N'2022-04-14T11:53:05.1630000' AS DateTime2), N'Not Reviewed', N'Planned', 1, 1, 1, 1, NULL)
  INSERT [dbo].[work_table] ([work_order_key], [modification_date], [from_status], [to_status], [count], [sequence], [count_VCR], [flag], [flag_expected]) VALUES (1002586, CAST(N'2022-04-19T03:49:25.7370000' AS DateTime2), N'Planned', N'In Progress', 1, 2, 1, 1, NULL)
  INSERT [dbo].[work_table] ([work_order_key], [modification_date], [from_status], [to_status], [count], [sequence], [count_VCR], [flag], [flag_expected]) VALUES (1002586, CAST(N'2022-04-19T04:22:33.0630000' AS DateTime2), N'In Progress', N'Awaiting Parts', 1, 3, 1, 1, NULL)
  INSERT [dbo].[work_table] ([work_order_key], [modification_date], [from_status], [to_status], [count], [sequence], [count_VCR], [flag], [flag_expected]) VALUES (1002586, CAST(N'2022-04-27T02:58:54.7570000' AS DateTime2), N'Awaiting Parts', N'Parts Ordered', 1, 4, 0, 1, NULL)
  INSERT [dbo].[work_table] ([work_order_key], [modification_date], [from_status], [to_status], [count], [sequence], [count_VCR], [flag], [flag_expected]) VALUES (1002586, CAST(N'2022-04-27T02:59:00.8530000' AS DateTime2), N'Parts Ordered', N'Parts Received', 1, 5, 0, 1, NULL)
  INSERT [dbo].[work_table] ([work_order_key], [modification_date], [from_status], [to_status], [count], [sequence], [count_VCR], [flag], [flag_expected]) VALUES (1002586, CAST(N'2022-04-27T02:59:09.9000000' AS DateTime2), N'Parts Received', N'Planned', 1, 6, 0, 1, NULL)
  INSERT [dbo].[work_table] ([work_order_key], [modification_date], [from_status], [to_status], [count], [sequence], [count_VCR], [flag], [flag_expected]) VALUES (1002586, CAST(N'2022-04-28T07:59:58.1130000' AS DateTime2), N'Planned', N'In Progress', 1, 7, 1, 1, NULL)
  INSERT [dbo].[work_table] ([work_order_key], [modification_date], [from_status], [to_status], [count], [sequence], [count_VCR], [flag], [flag_expected]) VALUES (1002586, CAST(N'2022-04-29T07:53:30.9030000' AS DateTime2), N'In Progress', N'Work Completed', 1, 8, 1, 1, NULL)
  INSERT [dbo].[work_table] ([work_order_key], [modification_date], [from_status], [to_status], [count], [sequence], [count_VCR], [flag], [flag_expected]) VALUES (1002586, CAST(N'2022-05-05T06:15:34.4300000' AS DateTime2), N'Work Completed', N'Completed', 1, 9, 0, 1, NULL)

Meu resultado esperado é

A coluna de partição é [work_order_key] e qualquer coluna da lista conforme adequado. Enquanto o loop pode obter essa resposta. Usei as colunas work_order_key e count_VCR para obter isso em um loop while. Mas quero verificar com o grupo a consulta direta usando qualquer janela SQL ou funções de classificação.

Não posso adicionar minha solução porque é de produção. Este é apenas um conjunto de dados de amostra. Obrigado pelo apoio.

Eu tenho uma tabela assim:

CREATE TABLE
  dbo.DiscountBarcodeList
(

  ID int NOT NULL IDENTITY
    CONSTRAINT PK_DiscountBarcodeList
    PRIMARY KEY CLUSTERED

, Discount int NOT NULL
    CONSTRAINT FK_DiscountBarcodeList_Discount
    FOREIGN KEY REFERENCES dbo.Discount (ID)

, CodeNumber int NOT NULL

, AssignedEntity int NULL
    CONSTRAINT FK_DiscountBarcodeList_AssignedEntity
    FOREIGN KEY REFERENCES dbo.Entity (ID)
    ON DELETE SET NULL

, BarcodeID AS
    CONVERT(
      char(10)
    , CAST(Discount AS binary(2)) + CAST(CodeNumber AS binary(3))
    , 2)

, CONSTRAINT UQ_DiscountBarcodeList_DiscountCodeNumber
    UNIQUE NONCLUSTERED 
    (
      Discount  ASC
    , CodeNumber ASC
    )

);

A tabela manterá CodeNumbers alocados para Discounts antecipadamente e atribuídos a Entitys sob demanda. Embora não esteja no nível do banco de dados, os valores de Discounte CodeNumberserão limitados a 2 bytes e 3 bytes, respectivamente. Essas limitações, juntamente com a restrição exclusiva de , também (Discount, CodeNumber)tornarão efetivamente os valores gerados únicos.BarcodeID

A forma como esta tabela deve ser usada é: o aplicativo passará um @BarcodeIDpara procurar @Entitye atribuir a ela. Se a pesquisa for bem-sucedida, as linhas Entityserão definidas como @Entityou o aplicativo será notificado de que @BarcodeIDjá foi usado, algo como isto:

BEGIN TRANSACTION;

UPDATE
SET
  @OldEntity = Entity
, Entity = @Entity
WHERE
  BarcodeID = @BarcodeID
;

IF @OldEntity IS NULL
BEGIN
  COMMIT TRANSACTION;
  ...  /* report success */
END

ELSE
BEGIN
  ROLLBACK TRANSACTION;
  ...  /* report failure */
END;

Agora eu gostaria de fazer BarcodeIDsargável. Como sei que a coluna terá apenas valores únicos, estou pensando em tornar o índice único, pois acho que isso pode tornar minha pesquisa mais eficiente. Por outro lado, estou preocupado que os valores gerados tenham que ser verificados quanto à exclusividade, o que é redundante aqui, uma vez que a exclusividade já está garantida.

É possível dizer de alguma forma se os benefícios, se houver, de um índice exclusivo em uma coluna computada superarão a provável sobrecarga da verificação de exclusividade (desnecessária neste caso)? Ou pelo menos é possível determinar isso para um cenário como o meu? Ou estou apenas pensando demais nisso?

Tenho aprendido um pouco de PL/SQL e estou tendo dificuldade em declarar e usar um tipo de tabela.

Eu sei que esse script é idiota e não adianta nada, só estou tentando aprender.

Aqui está minha consulta:

do $$
DECLARE
   TYPE employee_collection IS TABLE OF employee%ROWTYPE;
   emp_data employee_collection;
BEGIN
   SELECT * 
   BULK COLLECT INTO emp_data
   FROM employee;
END;
$$

Quando executo isso, recebo este erro: syntax error at or near "TABLE".

Em todos os lugares que procuro on-line, essa parece ser a maneira de fazer isso. Até copiei a maior parte desse código de um site.

Há um erro de sintaxe ou algo mais está acontecendo?

Estou executando o PostgreSQL 12.11.

ALTER FUNCTION [dbo].[NumberToWords](@Number DECIMAL(18, 2))
RETURNS NVARCHAR(MAX)
AS
BEGIN
DECLARE @Words NVARCHAR(MAX)

SELECT @Words = 
    COALESCE(@Words + ' ', '') +
    CASE
        WHEN @Number = 0 THEN ''
        WHEN @Number BETWEEN 1 AND 99 THEN 
            CASE @Number
                WHEN 1 THEN 'One'
                WHEN 2 THEN 'Two'
                WHEN 3 THEN 'Three'
                WHEN 4 THEN 'Four'
                WHEN 5 THEN 'Five'
                WHEN 6 THEN 'Six'
                WHEN 7 THEN 'Seven'
                WHEN 8 THEN 'Eight'
                WHEN 9 THEN 'Nine'
                WHEN 10 THEN 'Ten'
                WHEN 11 THEN 'Eleven'
                WHEN 12 THEN 'Twelve'
                WHEN 13 THEN 'Thirteen'
                WHEN 14 THEN 'Fourteen'
                WHEN 15 THEN 'Fifteen'
                WHEN 16 THEN 'Sixteen'
                WHEN 17 THEN 'Seventeen'
                WHEN 18 THEN 'Eighteen'
                WHEN 19 THEN 'Nineteen'
                WHEN 20 THEN 'Twenty'
                WHEN 21 THEN 'Twenty-one'
                WHEN 22 THEN 'Twenty-two'
                WHEN 23 THEN 'Twenty-three'
                WHEN 24 THEN 'Twenty-four'
                WHEN 25 THEN 'Twenty-five'
                WHEN 26 THEN 'Twenty-six'
                WHEN 27 THEN 'Twenty-seven'
                WHEN 28 THEN 'Twenty-eight'
                WHEN 29 THEN 'Twenty-nine'
                WHEN 30 THEN 'Thirty'
                WHEN 31 THEN 'Thirty-one'
                WHEN 32 THEN 'Thirty-two'
                WHEN 33 THEN 'Thirty-three'
                WHEN 34 THEN 'Thirty-four'
                WHEN 35 THEN 'Thirty-five'
                WHEN 36 THEN 'Thirty-six'
                WHEN 37 THEN 'Thirty-seven'
                WHEN 38 THEN 'Thirty-eight'
                WHEN 39 THEN 'Thirty-nine'
                WHEN 40 THEN 'Forty'
                WHEN 41 THEN 'Forty-one'
                WHEN 42 THEN 'Forty-two'
                WHEN 43 THEN 'Forty-three'
                WHEN 44 THEN 'Forty-four'
                WHEN 45 THEN 'Forty-five'
                WHEN 46 THEN 'Forty-six'
                WHEN 47 THEN 'Forty-seven'
                WHEN 48 THEN 'Forty-eight'
                WHEN 49 THEN 'Forty-nine'
                WHEN 50 THEN 'Fifty'
                WHEN 51 THEN 'Fifty-one'
                WHEN 52 THEN 'Fifty-two'
                WHEN 53 THEN 'Fifty-three'
                WHEN 54 THEN 'Fifty-four'
                WHEN 55 THEN 'Fifty-five'
                WHEN 56 THEN 'Fifty-six'
                WHEN 57 THEN 'Fifty-seven'
                WHEN 58 THEN 'Fifty-eight'
                WHEN 59 THEN 'Fifty-nine'
                WHEN 60 THEN 'Sixty'
                WHEN 61 THEN 'Sixty-one'
                WHEN 62 THEN 'Sixty-two'
                WHEN 63 THEN 'Sixty-three'
                WHEN 64 THEN 'Sixty-four'
                WHEN 65 THEN 'Sixty-five'
                WHEN 66 THEN 'Sixty-six'
                WHEN 67 THEN 'Sixty-seven'
                WHEN 68 THEN 'Sixty-eight'
                WHEN 69 THEN 'Sixty-nine'
                WHEN 70 THEN 'Seventy'
                WHEN 71 THEN 'Seventy-one'
                WHEN 72 THEN 'Seventy-two'
                WHEN 73 THEN 'Seventy-three'
                WHEN 74 THEN 'Seventy-four'
                WHEN 75 THEN 'Seventy-five'
                WHEN 76 THEN 'Seventy-six'
                WHEN 77 THEN 'Seventy-seven'
                WHEN 78 THEN 'Seventy-eight'
                WHEN 79 THEN 'Seventy-nine'
                WHEN 80 THEN 'Eighty'
                WHEN 81 THEN 'Eighty-one'
                WHEN 82 THEN 'Eighty-two'
                WHEN 83 THEN 'Eighty-three'
                WHEN 84 THEN 'Eighty-four'
                WHEN 85 THEN 'Eighty-five'
                WHEN 86 THEN 'Eighty-six'
                WHEN 87 THEN 'Eighty-seven'
                WHEN 88 THEN 'Eighty-eight'
                WHEN 89 THEN 'Eighty-nine'
                WHEN 90 THEN 'Ninety'
                WHEN 91 THEN 'Ninety-one'
                WHEN 92 THEN 'Ninety-two'
                WHEN 93 THEN 'Ninety-three'
                WHEN 94 THEN 'Ninety-four'
                WHEN 95 THEN 'Ninety-five'
                WHEN 96 THEN 'Ninety-six'
                WHEN 97 THEN 'Ninety-seven'
                WHEN 98 THEN 'Ninety-eight'
                WHEN 99 THEN 'Ninety-nine'
            END
        WHEN @Number BETWEEN 100 AND 999 THEN 
            dbo.NumberToWords(@Number / 100) + ' Hundred ' + dbo.NumberToWords(@Number % 100)
        WHEN @Number BETWEEN 1000 AND 999999 THEN 
            dbo.NumberToWords(@Number / 1000) + ' Thousand ' + dbo.NumberToWords(@Number % 1000)
        WHEN @Number BETWEEN 1000000 AND 999999999 THEN 
            dbo.NumberToWords(@Number / 1000000) + ' Million ' + dbo.NumberToWords(@Number % 1000000)
        ELSE 'Value too large'
    END
        
RETURN @Words
END

Para chamá-lo estou usando

DECLARE @Number DECIMAL(18, 2) = 1004
SELECT dbo.NumberToWords(@Number) AS Words

ERROS DE CASO:

• 20 ✅ Vinte
• 100 ✅ Cem
• 101 ❌ NULO
• 102 ❌ NULO
• 105 ❌ NULO
• 200 ✅ Duzentos
• 204 ❌ NULO
• 1000 ✅ Mil
• 1004 ✅ Mil e Quatro
• 1005 ❌ NULO
• 1020 ❌ NULO

Achei que era porque não poderia recorrer mais de uma vez, mas lida com Mil e Quatro sem problemas.

Considere o seguinte código de exemplo mínimo, completo e verificável (veja dbfiddle aqui ):

CREATE TABLE [dbo].[test]
(
      [i] bigint NOT NULL 
        identity(1,1) 
        PRIMARY KEY CLUSTERED
    , [d] varchar(10) NOT NULL
);
GO

Com um INSTEAD OF INSERT, UPDATEgatilho:

CREATE TRIGGER [dbo_test_trigger]
ON [dbo].[test]
INSTEAD OF INSERT, UPDATE
AS
BEGIN
    IF ROWCOUNT_BIG() = 0 RETURN;

    SET NOCOUNT ON;

    MERGE INTO [dbo].[test] [target]
    USING [inserted] [source] ON [target].[i] = [source].[i]
    WHEN NOT MATCHED THEN
        INSERT
        (
            [d]
        )
        VALUES 
        (
            [source].[d]
        )
    WHEN MATCHED THEN 
        UPDATE
        SET [target].[d] = [source].[d];
END;
GO

Estou executando um insert na tabela, na esperança de obter o valor da identidade inserida, porém o valor retornado é 0:

DECLARE @output TABLE
(
      [i] bigint NOT NULL
    , [d] varchar(10) NOT NULL
);

INSERT INTO [dbo].[test]
(
    [d]
)
OUTPUT 
      [inserted].[i]
    , [inserted].[d]
INTO @output 
(
      [i]
    , [d]
) 
VALUES ('test');

/* shows [i] is 0 */
SELECT *
FROM @output;

/* shows [i] is 1 */
SELECT *
FROM [dbo].[test];

Os resultados são:

e

O resultado desejado seria que ambos os conjuntos de resultados correspondessem, mas isso não acontece.

O que estou fazendo de errado?

Eu vi isso, no entanto, que parece bem diferente, já que não estou usando nenhuma visualização. O gatilho está na mesa no meu exemplo.

Suponha que temos uma extensão hipotética chamada xyz com versão 1.0. Tem xyz--1.0.sqle xyz.carquivo. Declarei a função chamada fun() no xyz--1.0.sqlarquivo e sua definição no xyz.carquivo.

Agora eu queria descartar essa função na próxima atualização, ou xyz--1.0--1.1seja, vou usá DROP FUNCTION fun();-la e remover a definição do xyz.carquivo.

Aqui, minha dúvida é: não xyz--1.0reclamarei da falta de definição de fun() e, se sim, como posso limpar minha definição de função no xyz.carquivo?

Alterei a estrutura da tabela e estou prestes a remover a coluna JSONB antiga de uma tabela grande com cerca de 2,5 milhões de linhas. O JSONB torna esta tabela realmente grande - pg_total_relation_size: 408GB

O desempenho ALTER TABLE ... DROP COLUMN ..;foi tão pesado que bloqueou todo o banco de dados e causou 502 na maioria dos serviços.

PERGUNTA: se eu definir a coluna JSONB como NULL antes de executar ALTER TABLE DROP COLUMN, ela será mais rápida? Ou existe alguma outra opção, excluindo aquela que lida com todas as colunas, exceto aquela que visa colocar em uma tabela separada e trocar os nomes depois?

Atualizei para o MySQL 8.3 e gostaria de configurá-lo para permitir conexões remotas.

Eu estava usando onde $PASSWORD é a senha, mas estou recebendo o seguinte erro e estou um pouco confuso. Alguma ideia do que deveria ser?

mysql> GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' IDENTIFIED BY '$PASSWORD';
ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'IDENTIFIED BY ''' at line 1
mysql> 

Eu estava tentando fazer https://dev.mysql.com/doc/refman/8.0/en/replication-howto-masterstatus.html até que o comando para pausar todas as gravações obtivesse acesso negado em meu banco de dados de teste

FLUSH TABLES WITH READ LOCK;
Error Code 1045. Access denied for user 'admin'@'%'

Portanto, no Aurora RDS, como faço para pausar todas as gravações, capturar o nome do arquivo de log binário e compensar, tirar um instantâneo e, em seguida, retomar todas as gravações?

Então, posso restaurar o instantâneo e espero que a configuração comece a replicar a partir desse deslocamento para alcançar o banco de dados de origem.

Na minha máquina SQL Server 2019, tenho um banco de dados em execução no nível de compatibilidade mais baixo suportado (acredito que seja equivalente ao SQL Server 2008). Eu quero mudar para o mais alto. Preciso verificar primeiro os recursos obsoletos?

Parece que deveria ser uma duplicata, mas não consegui encontrar nada mencionando os dois tópicos.