's questions

Digamos que temos a tabela abaixo conosco:

 id |     entry_time      |  state  
----+---------------------+---------
 d1 | 2024-09-20 12:01:01 | Open
 d1 | 2024-09-20 12:01:20 | EnRoute
 d1 | 2024-09-20 12:02:40 | OnTrip
 d1 | 2024-09-20 12:04:10 | Open

E queremos uma visualização final que ficará como abaixo (saída esperada):

| id | start_minute        | open_time | enroute_time | ontrip_time |
|----|---------------------|-----------|--------------|-------------|
| d1 | 2024-09-20 12:01:00 | 19        | 40           | 0           |
| d1 | 2024-09-20 12:02:00 | 0         | 40           | 20          |
| d1 | 2024-09-20 12:03:00 | 0         | 0            | 60          |
| d1 | 2024-09-20 12:04:00 | 50        | 0            | 10          |

Para calcular a visualização (para a primeira linha)

• open_time é 19 porque o driver permaneceu em estado aberto de 12:01:01 a 12:01:20
• enroute_time é 40 porque o motorista permaneceu no estado enroute de 12:01:20 a 12:02:00 (e permaneceu até 2024-09-20 12:02:40, marcador do próximo minuto)

Eu estava tentando calcular o mesmo, mas não tinha 100% de certeza de como prosseguir:

• Estou um pouco preso tentando descobrir como dividir o campo de registro de data e hora em rastreador de minutos

  • Eu estava lendo mais sobre funções de agregação e data e hora e date_trunc pode ser usado para conseguir isso para agrupar os registros

• Estou tentando descobrir como fazer algo como uma tabela dinâmica que pode ser útil para nos ajudar a chegar à resposta final (no meu entendimento limitado)

OU:

• Precisamos encontrar a proporção para cada intervalo de minuto dado o estado, para que possamos conseguir isso calculando o marcador de tempo inicial e final para cada estado após explodir a visualização para o marcador de minuto da tabela atual. Essa é uma boa ideia ou pode haver uma abordagem melhor?

Minha tentativa:

select 
    id,
    state,
    date_trunc('minute', entry_time + interval '30 second') AS trunc_min,
    entry_time as curr_time,
    date_trunc('minute', entry_time + interval '60 second') AS ceil_min,
    LEAD(entry_time) over (PARTITION by id order by entry_time) as next_time,
    extract(epoch from (lead(entry_time) over (partition by id order by entry_time) - entry_time)) as duration
from (
    values 
    ('d1', '2024-09-20 12:01:01'::timestamp, 'Open'),
    ('d1', '2024-09-20 12:01:20'::timestamp, 'EnRoute'), 
    ('d1', '2024-09-20 12:02:40'::timestamp, 'OnTrip'),
    ('d1', '2024-09-20 12:04:10'::timestamp, 'Open')
) t("id", "entry_time", "state");

Saída:

 id |  state  |      trunc_min      |      curr_time      |      ceil_min       |      next_time      | duration  
----+---------+---------------------+---------------------+---------------------+---------------------+-----------
 d1 | Open    | 2024-09-20 12:01:00 | 2024-09-20 12:01:01 | 2024-09-20 12:02:00 | 2024-09-20 12:01:20 | 19.000000
 d1 | EnRoute | 2024-09-20 12:01:00 | 2024-09-20 12:01:20 | 2024-09-20 12:02:00 | 2024-09-20 12:02:40 | 80.000000
 d1 | OnTrip  | 2024-09-20 12:03:00 | 2024-09-20 12:02:40 | 2024-09-20 12:03:00 | 2024-09-20 12:04:10 | 90.000000
 d1 | Open    | 2024-09-20 12:04:00 | 2024-09-20 12:04:10 | 2024-09-20 12:05:00 |                     |          

Como prosseguir a partir daqui?

Tenho uma tabela Postgres com 350M registros. Tenho 3x índices nela:

historical_offers(recovery_date, uprn)
historical_offers(recovery_date, account_id)
historical_offers(recovery_date, individual_id)

Se eu executar uma consulta para uma data mais antiga que 24 horas, ela é rápida. Mas se eu executar para hoje (e às vezes ontem), ela é muito lenta (0,05 ms vs 300 ms).

Minha consulta está em todos os campos 3x e usa os índices 3x, então mistura os resultados de forma agradável e rápida para datas > 24 horas~. Então, não acho que seja um problema com a condição OR nos campos 3x que precisam usar índices 3x. Além disso: se eu modificar a consulta para executar APENAS em 1 campo, terei o mesmo problema.

Teorias atuais:

• há atraso na gravação dos índices (mas pensei que os índices fossem atualizados ao mesmo tempo que a tabela é atualizada)
• o planejamento de consulta está estragando e usando o menor índice (eu li algo que essa é uma prática conhecida do Postgres). Talvez eu precise adicionar dicas para "forçá-lo" a usar os índices corretos?

Resposta lenta (hoje):

EXPLAIN ANALYZE SELECT * FROM historical_offers.historical_offers WHERE (historical_offers.uprn = '1001005' OR historical_offers.account_id = 'SW1006' OR historical_offers.individual_id = '6752da6') AND (historical_offers.recovery_date = '2025-01-02');
+------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| QUERY PLAN                                                                                                                                                       |
|------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Index Scan using historical_offers_date_individual_id_idx on historical_offers  (cost=0.57..8.56 rows=1 width=174) (actual time=346.467..346.467 rows=0 loops=1) |
|   Index Cond: (recovery_date = '2025-01-02'::date)                                                                                                               |
|   Filter: (((uprn)::text = '1001005'::text) OR ((account_id)::text = 'SW1006'::text) OR ((individual_id)::text = '6752da6'::text))     |
|   Rows Removed by Filter: 1470748                                                                                                                                |
| Planning Time: 0.099 ms                                                                                                                                          |
| Execution Time: 346.488 ms                                                                                                                                       |
+------------------------------------------------------------------------------------------------------------------------------------------------------------------+
EXPLAIN 6
Time: 0.383s

Consulta rápida (data 2 dias atrás):

EXPLAIN ANALYZE SELECT * FROM historical_offers.historical_offers WHERE (historical_offers.uprn = '1001005' OR historical_offers.account_id = 'SW1006' OR historical_offers.individual_id = '6752da6') AND (historical_offers.recovery_date = '2025-01-01');
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| QUERY PLAN                                                                                                                                                                                                                                                                                          |
|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Bitmap Heap Scan on historical_offers  (cost=13.88..78.14 rows=16 width=174) (actual time=0.031..0.032 rows=0 loops=1)                                                                                                                                                                              |
|   Recheck Cond: (((recovery_date = '2025-01-01'::date) AND ((uprn)::text = '1001005'::text)) OR ((recovery_date = '2025-01-01'::date) AND ((account_id)::text = 'SW1006'::text)) OR ((recovery_date = '2025-01-01'::date) AND ((individual_id)::text = '6752da6'::text))) |
|   ->  BitmapOr  (cost=13.88..13.88 rows=16 width=0) (actual time=0.030..0.030 rows=0 loops=1)                                                                                                                                                                                                       |
|         ->  Bitmap Index Scan on historical_offers_date_uprn_idx  (cost=0.00..4.62 rows=5 width=0) (actual time=0.013..0.013 rows=0 loops=1)                                                                                                                                                        |
|               Index Cond: ((recovery_date = '2025-01-01'::date) AND ((uprn)::text = '1001005'::text))                                                                                                                                                                                          |
|         ->  Bitmap Index Scan on historical_offers_date_account_id_idx  (cost=0.00..4.62 rows=5 width=0) (actual time=0.008..0.008 rows=0 loops=1)                                                                                                                                                  |
|               Index Cond: ((recovery_date = '2025-01-01'::date) AND ((account_id)::text = 'SW1006'::text))                                                                                                                                                                                      |
|         ->  Bitmap Index Scan on historical_offers_date_individual_id_idx  (cost=0.00..4.62 rows=5 width=0) (actual time=0.008..0.008 rows=0 loops=1)                                                                                                                                               |
|               Index Cond: ((recovery_date = '2025-01-01'::date) AND ((individual_id)::text = '6752da6'::text))                                                                                                                                                                     |
| Planning Time: 0.113 ms                                                                                                                                                                                                                                                                             |
| Execution Time: 0.054 ms                                                                                                                                                                                                                                                                            |
+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
EXPLAIN 11
Time: 0.026s

Minha pergunta é bem simples: um RESTORE do DB2 em um servidor pode afetar o servidor onde o backup se originou? Ou seja, o comando RESTORE do DB2 pode contatar o servidor original e fazer "algo" porque ele armazena o nome do servidor e as credenciais do DB no backup?

Estou usando o DB2 para Windows, v11.1 no SERVIDOR1 e v11.5 FP9 no SERVIDOR 2. Estou fazendo isso para estabelecer um sistema de teste em um servidor separado com os dados de produção.

A sequência de eventos foi a seguinte:

1. Eu faço um BACKUP do DB2 no SERVER1
2. Eu copio os arquivos de backup para SERVER2
3. Eu faço um RESTORE do DB2 no SERVER2

No EXATO mesmo momento em que inicio a RESTAURAÇÃO do DB2 no SERVIDOR2, começo a receber os seguintes erros no db2diag no SERVIDOR1:

A validação da senha do usuário db2admin falhou com rc = -2146500483

Estou bastante perdido aqui e interrompi o processo por enquanto.

Uma teoria que tenho é que ambas as instalações do DB2 estão residindo no mesmo SAN, e talvez a RESTAURAÇÃO do DB2 seja tão intensa que interrompa a operação do DB2 SERVER1.

Obrigado, /Morten.

Estou conectado à máquina Windows e conectado a outro ambiente por meio do GlobalProtect VPN para conectar o SQL Server. O SQL Server está configurado para permitir apenas a autenticação do Windows. Porém, a máquina Windows está em um domínio e o SQL Server está em outro domínio. E quando estou tentando conectar, ocorre um erro:

O nome principal de destino está incorreto. Não é possível gerar o contexto SSPI.
(Provedor de dados da estrutura Microsoft SqlClient)

É assim que estou tentando conseguir isso:

Mas está retornando erro como:

Aqui estão os detalhes:

                                               QUERY PLAN                                                                                        

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

GroupAggregate  (cost=21267.11..21286.98 rows=461 width=31) (actual time=1.711..1.712 rows=1 loops=1)
Group Key: *
\-\>  Sort  (cost=21267.11..21268.91 rows=719 width=35) (actual time=1.564..1.591 rows=719 loops=1)
Sort Key: *
Sort Method: quicksort  Memory: 69kB
\-\>  Nested Loop  (cost=70.03..21233.00 rows=719 width=35) (actual time=0.483..1.454 rows=719 loops=1)
\-\>  Index Scan using *  (cost=0.28..8.30 rows=1 width=27) (actual time=0.017..0.018 rows=1 loops=1)
Index Cond: *
\-\>  Bitmap Heap Scan on measurements m  (cost=69.75..21213.91 rows=719 width=32) (actual time=0.240..0.994 rows=719 loops=1)
Recheck Cond: *
Filter: *
Rows Removed by Filter: 5241
Heap Blocks: exact=50
\-\>  Bitmap Index Scan on * (cost=0.00..69.57 rows=6018 width=0) (actual time=0.224..0.224 rows=5960 loops=1)
Index Cond: *
Planning Time: 0.697 ms
**Execution Time: 1.766 ms**
(17 rows)

                                              QUERY PLAN                                                                                        

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

GroupAggregate  (cost=21267.11..21286.98 rows=461 width=31) (actual time=0.897..0.898 rows=1 loops=1)
Group Key: *
\-\>  Sort  (cost=21267.11..21268.91 rows=719 width=35) (actual time=0.795..0.831 rows=719 loops=1)
Sort Key: *
Sort Method: quicksort  Memory: 69kB
\-\>  Nested Loop  (cost=70.03..21233.00 rows=719 width=35) (actual time=0.178..0.718 rows=719 loops=1)
\-\>  Index Scan using * (cost=0.28..8.30 rows=1 width=27) (actual time=0.004..0.005 rows=1 loops=1)
Index Cond: *
\-\>  Bitmap Heap Scan on measurements m  (cost=69.75..21213.91 rows=719 width=32) (actual time=0.081..0.457 rows=719 loops=1)
Recheck Cond: *
Filter: *
Rows Removed by Filter: 5241
Heap Blocks: exact=50
\-\>  Bitmap Index Scan on * (cost=0.00..69.57 rows=6018 width=0) (actual time=0.073..0.073 rows=5960 loops=1)
Index Cond: * 
Planning Time: 0.336 ms
**Execution Time: 0.929 ms**
(17 rows)

                                              QUERY PLAN                                                                                        

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

GroupAggregate  (cost=21267.11..21286.98 rows=461 width=31) (actual time=0.873..0.873 rows=1 loops=1)
Group Key: *
\-\>  Sort  (cost=21267.11..21268.91 rows=719 width=35) (actual time=0.794..0.813 rows=719 loops=1)
Sort Key: *
Sort Method: quicksort  Memory: 69kB
\-\>  Nested Loop  (cost=70.03..21233.00 rows=719 width=35) (actual time=0.168..0.717 rows=719 loops=1)
\-\>  Index Scan using * (cost=0.28..8.30 rows=1 width=27) (actual time=0.004..0.004 rows=1 loops=1)
Index Cond: *
\-\>  Bitmap Heap Scan on measurements m  (cost=69.75..21213.91 rows=719 width=32) (actual time=0.071..0.457 rows=719 loops=1)
Recheck Cond: * 
Filter: *
Rows Removed by Filter: 5241
Heap Blocks: exact=50
\-\>  Bitmap Index Scan on * 
(cost=0.00..69.57 rows=6018 width=0) (actual time=0.063..0.063 rows=5960 loops=1)
Index Cond: *
Planning Time: 0.304 ms
**Execution Time: 0.903 ms**
(17 rows)

\---------------------------------------------------------------------------------------------------------------

Time (mean ± σ):      **98.1 ms** ±  28.1 ms    \[User: 30.7 ms, System: 11.1 ms\]Range (min … max):    75.6 ms … 129.5 ms    3 runs

\---------------------------------------------------------------------------------------------------------------  

Estou usando o hyperfine para avaliar o desempenho da minha consulta no PostgreSQL. Usei --runs 3a opção de executá-lo três vezes. Como você pode ver, o tempo de execução para todas as três vezes em que executo a consulta leva 1,766, 0,929 e 0,903 ms, respectivamente. Minha pergunta é: por que a média é = 98,1 ms? O que isso significa representa? Porque não faz sentido que o tempo de execução esteja entre 0,9 ms - 1,7 ms, enquanto a média deles é de 98,1 ms. Testei executar essa mesma consulta no Postico e demorou 0,903 ms. Só estou curioso para saber o que a média representa se não representa o tempo médio de execução.

Tenho pesquisado na internet a melhor maneira de instalar o sqlplus no chip de silício da Apple MacOs (processador de bases de braço). por favor, guie-me com algum método mais fácil de fazer isso.

Eu vi muitos artigos sobre a instalação do sqlplus no processador baseado em Intel x64, mas não para o processador baseado em arm64.

Mais alguns detalhes sobre o sistema

Chip Apple M1 Pro Mac OS versão Mac OS Sonoma 14.3.1

Tive uma migração do SQL Server 2014 para o SQL Server 2022.

Primeiro criei backups COMPLETOS da instância do SQL Server 2014 e, em seguida, executei RESTORE DATABASEo script mostrado abaixo para fazer uma migração de teste. Tudo funcionou conforme planejado.

Uma semana depois, descartei todos os bancos de dados no novo servidor, fiz backup do SQL Server 2014 novamente com os mesmos nomes de arquivo e executei novamente o script abaixo. No entanto, o SQL Server 2022 não restaurou a versão mais recente do arquivo e, em vez disso, restaurou apenas os dados da semana anterior. Apenas clicar com o botão direito na IU e fazer uma "restauração" a partir daí restaurou a versão atual dos dados.

Alguém pode me ajudar a entender por que isso evita isso no futuro?

BACKUP DATABASE db1 TO DISK = db1.BAK;  

RESTORE DATABASE [db1]
FROM DISK = N'\\sql2014\migration\db1.BAK' WITH FILE = 1, 
     MOVE N'db1_data' TO N'D:\Data\db1_data.mdf', 
     MOVE N'db1_log' TO N'D:\Log\db1_log.ldf',
     NOUNLOAD,
     REPLACE,
     STATS = 5;
GO

Estou criando uma tabela com lógica de particionamento. Abaixo está a função e o esquema da partição:

DECLARE @StartDate datetime2 = '20230401';
DECLARE @YearlyQuartersPartitionFunction nvarchar(max) = N'CREATE PARTITION FUNCTION YearlyQuartersPartitionFunction (datetime2) AS RANGE RIGHT FOR VALUES (';  

DECLARE @i datetime2 = @StartDate;  
WHILE @i < '20300101'  
BEGIN  
    SET @YearlyQuartersPartitionFunction += '''' + CAST(@i as nvarchar(10)) + '''' + N', ';  
    SET @i = DATEADD(MM, 3, @i);  
END  
SET @YearlyQuartersPartitionFunction += '''' + CAST(@i as nvarchar(10))+ '''' + N');';  
--PRINT @YearlyQuartersPartitionFunction;
EXEC sp_executesql @YearlyQuartersPartitionFunction; 
GO

Se você executar o bloco para criar a função de partição descomentando a instrução PRINT, verá o seguinte:

CREATE PARTITION FUNCTION YearlyQuartersPartitionFunction (datetime2) AS RANGE RIGHT FOR VALUES ('2023-04-01', '2023-07-01', '2023-10-01', '2024-01-01', '2024-04-01', '2024-07-01', '2024-10-01', '2025-01-01', '2025-04-01', '2025-07-01', '2025-10-01', '2026-01-01', '2026-04-01', '2026-07-01', '2026-10-01', '2027-01-01', '2027-04-01', '2027-07-01', '2027-10-01', '2028-01-01', '2028-04-01', '2028-07-01', '2028-10-01', '2029-01-01', '2029-04-01', '2029-07-01', '2029-10-01', '2030-01-01');

-- Partition scheme that maps to the PRIMARY filegroup
CREATE PARTITION SCHEME YearlyQuartersPartitionScheme
AS PARTITION YearlyQuartersPartitionFunction
ALL TO ([PRIMARY]);

E estou usando este esquema para criar uma tabela usando o DDL abaixo:

CREATE TABLE [dbo].[MyTable](
    [Id] [uniqueidentifier] NOT NULL,
    [CompanyId] [uniqueidentifier] NOT NULL,
    [AddedUtc] [datetime2](7) NOT NULL,
    [IsTest] [bit] NOT NULL
) ON YearlyQuartersPartitionScheme(AddedUtc) ON PRIMARY;
GO
ALTER TABLE [dbo].[MyTable] ADD  CONSTRAINT [PK_MyTable] PRIMARY KEY CLUSTERED 
(
    [Id] ASC
)WITH (STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ONLINE = OFF, OPTIMIZE_FOR_SEQUENTIAL_KEY = OFF) ON [PRIMARY]
GO
CREATE NONCLUSTERED INDEX [IX_MyTable_CompanyId] ON [dbo].[MyTable]
(
    [CompanyId] ASC
)WITH (STATISTICS_NORECOMPUTE = OFF, DROP_EXISTING = OFF, ONLINE = OFF, OPTIMIZE_FOR_SEQUENTIAL_KEY = OFF) ON [PRIMARY]
GO
ALTER TABLE [dbo].[MyTable] ADD  DEFAULT (CONVERT([bit],(0))) FOR [IsTest]
GO
ALTER TABLE [dbo].[MyTable]  WITH CHECK ADD  CONSTRAINT [FK_MyTable_Companies_CompanyId] FOREIGN KEY([CompanyId])
REFERENCES [dbo].[Companies] ([Id])
ON DELETE CASCADE
GO
ALTER TABLE [dbo].[MyTable] CHECK CONSTRAINT [FK_MyTable_Companies_CompanyId]
GO

Se eu verificar as partições criadas para esta tabela, vejo que todas as partições têm o mesmo valor de número_de_partição. Isto está errado.

Alguém pode apontar se estou fazendo algo flagrantemente errado.

Percebo que o data_space_id do esquema de partição não corresponde ao data_space_id dos índices da tabela.

quando preciso reconstruir um index.

estamos usando em índices de bitmap de data warehouse. se eu truncar a tabela e não houver nenhuma linha e depois inserir novas linhas, um índice deve ser reconstruído, até onde eu sei, porque isso faz sentido.

É sempre verdadeiro quando uma nova linha é atualizada, inserida ou excluída, não importa se com instruções únicas ou usando a instrução de mesclagem, o Oracle atualiza todos os tipos de índices automaticamente?

Adicionei registros a uma tabela de banco de dados do SQL Server. A tabela tinha uma chave primária estabelecida e a semente de identidade de incremento automático está definida como "Sim". Isso é feito principalmente porque, com o SQL Azure, cada tabela deve ter uma chave primária e uma identidade declarada.

No entanto, como preciso remover determinados itens da tabela, a semente de identificação dessas tabelas será interrompida, assim como a coluna de índice (que é gerada automaticamente com um incremento de 1).

Como posso redefinir a coluna de identidade depois de excluir as entradas de forma que a sequência da coluna esteja em ordem numérica crescente?

O campo de identificação não é utilizado como uma chave estrangeira em nenhum lugar do banco de dados.

CREATE TABLE IF NOT EXISTS `users` (
    id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
    username VARCHAR(255) NOT NULL,
    password VARCHAR(255) NOT NULL,
    org_id  int NOT NULL,
    phonenum int NOT NULL
)  ENGINE=INNODB;

INSERT INTO `users` VALUES (1, 'USER','abcd', 1, 1);

isso gera um erro: ERROR 1062 (23000) at line 13: Duplicate entry '1' for key 'users.PRIMARY'

Obrigado pela ajuda!

temos um aplicativo Ruby on Rails com um banco de dados MySQL (no AWS RDS). Algumas de nossas tabelas têm um grande número de registros ~ 100 milhões e esse número está aumentando rapidamente a cada mês. A maioria dos registros dessas tabelas estão inativos e são acessados ​​apenas ocasionalmente para alguns relatórios que os usuários podem acessar.

Estamos agora enfrentando vários problemas:

• o tempo de consulta nessas tabelas aumentou significativamente mesmo com a otimização do índice
• restaurar a partir de um backup em caso de emergência levaria muito tempo devido ao grande tamanho das tabelas

Nossos requisitos são:

• os dados precisam ser persistidos indefinidamente em algum lugar
• (rápido) acesso de leitura aos dados
• nenhum acesso de gravação adicional é necessário após um certo período desde a criação de um registro
• baixo custo

Estávamos, portanto, planejando fazer o seguinte:

• depois que um registro ficar "inativo" (isso é amplamente determinado por um período de tempo que se passou desde a criação), criaríamos um registro no DynamoDB espelhando os dados em nosso banco de dados sql.
• depois de vários dias, excluímos o registro sql do banco de dados mysql
• o registro ainda pode ser lido através do dynamodb

Nossa pergunta era se esse tipo de abordagem é convencional e se existem maneiras potencialmente melhores de alcançar o que queremos. Qualquer entrada seria muito apreciada.

A pergunta pergunta:

Dadas duas relações A e B, ambas sobre os atributos x e y. Escreva uma consulta na semântica do saco que retorne A se B estiver vazio e B caso contrário

A maneira como interpretei essa pergunta como "vazia" significava que não havia tuplas na relação.

A questão é dada em um sentido geral para que não haja valores associados a cada relação.

Espero que alguém possa me dar uma orientação para começar.

Edit: Até agora, vejo que, se B estiver vazio, A união B produziria a resposta correta. Mas no caso de B não estar vazio, precisaríamos fazer a interseção com B , ou seja (A união B) cruzar B , mas isso não funcionaria quando B estiver vazio

Edit: Para dar um exemplo no caso em que A e B não estavam vazios:

R : ((1,1), (2,2))

B : ((3,3), (4,4))

A consulta deve retornar: ((3,3), (4,4))

Mas, se mudarmos B para: ()

A consulta deve retornar: ((1,1), (2,2))

Eu simplesmente não consigo entender qual combinação possível de operadores de conjunto me permitiria alcançar isso.

Edit: Aqui está um link para basicamente o deck de slides exato usado para nos ensinar Álgebra Relacional, cerca de 3/4 do caminho define Álgebra em sacos, que é o que minha pergunta usa. O livro-texto usado em aula é "Sistemas de Gerenciamento de Banco de Dados" de Ramakrishnan e Gehrke 3ª edição, página 100, mas este era um texto opcional e nos disseram que nossa principal referência deveria ser o conjunto de slides.

Para condensar os slides, nossa álgebra possui Seleção, Projeção, Renomeação, Produto Cartesiano, União e Diferença. Todas as outras operações podem ser feitas com uma combinação destas.

Para resolver de onde o problema se originou, foi de uma antiga planilha de problemas que eu tinha para o meu módulo de bancos de dados no semestre passado, revisei-a recentemente para revisar a álgebra relacional para um projeto futuro que tenho, mas essa pergunta me deixou perplexo por alguns dias. O professor que apresentou os problemas foi embora, então infelizmente não posso perguntar a eles.

Eu preciso criar backups de log de transações de um banco de dados com os nomes dos arquivos de alguma forma numerados de forma incremental, um por hora, ao longo do dia.

Exemplo:

9h - mydb 01 .trn

10h - mydb 02 .trn

11h - mydb 03 .trn

etc.

Não quero a data ou hora anexadas a eles porque nossos instantâneos SAN cuidarão do controle de versão. Esses nomes têm que ser os mesmos todos os dias.

Eu gostaria de fazer isso sem ter que criar um emprego para cada hora do dia. Eu simplesmente não consegui descobrir isso usando o T-SQL básico, que é o limite das minhas habilidades em T-SQL. Eu sei que poderia criar um monte de tarefas com comandos de backup padrão como abaixo, com um nome de arquivo diferente e horário agendado, no entanto, deve haver uma maneira melhor.

BACKUP LOG [mydb] TO DISK = N'X:\SQLBackups\mydb01.trn.trn'
    ,NAME = N'mydb_backup'
    ,COMPRESSION
    ,STATS = 10
    ,CHECKSUM
GO

Minha aplicação precisa enviar um email diário para os usuários no horário de sua escolha, o fuso horário também é definido pelo próprio usuário.

Qual é a melhor maneira de armazenar HH:MM + fuso horário? E como posso consultar isso efetivamente, sabendo que meu servidor está em um fuso horário específico?

Minha tabela atual é:

CREATE TABLE "reminder" (
    "id"            SERIAL          UNIQUE PRIMARY KEY,
    "user"          INT             NOT NULL REFERENCES "user"(id) ON DELETE CASCADE,
    "scheduled_at   TIMESTAMPTZ     NOT NULL,
    "created_at"    TIMESTAMPTZ     NOT NULL DEFAULT CURRENT_TIMESTAMP
)

Não tenho certeza se TIMESTAMPTZé a maneira mais eficaz de fazer isso, pois armazena todo o carimbo de data e hora, e não apenasHH:MM

Eu tenho 4 tabelas (75 colunas cada tabela aprox), mas elas compartilham colunas com o mesmo nome:

Tabela Mestre_Produto

Master_Product.PD_Prof_21

Tabela Produto_Estrutura

Product_Structure.PD_Prof_21

Estou fazendo junção esquerda; o que acontece é que ao trazê-los para o backend (php) eles são sobrescritos... espera-se 2 PD_Prof_21 mas no php apenas um é recuperado.

com base nessa solução (que não resolve meu cenário, pois tenho cerca de 300 colunas) https://stackoverflow.com/a/10530252/4717133

Não estou convencido da ideia de usar aliases com mais de 300 colunas... sei que os aliases nas colunas seriam algo como:

SELECT Columns as column1 ... // this would be very heavy to do for each column ...

Esta outra opção, não separa as tabelas no conjunto de resultados

SELECT 
Master_Product.*,
Product_Structure.*,
Supplier_Product.*,
Product_Price.*,

ou pelo menos no php estou com problemas, acontece que das 300 colunas só recebo aquelas que não se repetem, se uma coluna for repetida, só me mostra a última com o último valor.

Primeira dúvida

Então eu queria saber se existe algum método no mysql que permita adicionar um prefixo automaticamente a todas as colunas em uma consulta do conjunto de resultados, um exemplo:

SELECT PREFIX ('Master_', Master_Product. *), PREFIX ('Structure_', Product_Structure. *) ...

e em PHP acesso a:

Master_PD_Prof_21
Structure_PD_Prof_21

Script PHP usado para recuperar as informações:

Conexões

function Open_Con_DB2($dbUsing) {
        $dblink = mysqli_connect(DB_HOST, DB_USERNAME, DB_PASS, DB_PRE . $dbUsing);
        
        if ($dblink) {
            $dblink->query("SET NAMES 'utf8'"); # Enlace de Coneccion UTF-8
            return $dblink;
        } else {
            #No conviene mostrar errores internos
            #Cámbialos por mensajes personalizados en producción
            die( 'Error de Conexión ('
                 .mysqli_connect_errno(). ') '
                 . mysqli_connect_error()
                );
            return null;
        }
    }

Obter informação.

function BDquery2($dbquery, $dbUsing) {
        $dblink = $this->Open_Con_DB2($dbUsing);
        if ($dblink) {
            if ( $datos = mysqli_query($dblink, $dbquery) ) {
                $outPut=array();
                while ($row = mysqli_fetch_assoc($datos)) {
                    $outPut[]=$row;
                }
            } else {
                $outPut['error']=$this->errorDB($dblink);
            }
            $this->Close_Con_DB($dblink);
        } else {
            $outPut['error']='No hay conexión';
        }
        return $outPut;
    }

Consulta Executada: (desculpe mas o banco de dados está em espanhol XD)

SELECT 
Master_Producto.*, 
Producto_Estructura.*,
Producto_Proveedor.*,
Producto_Precio.*,
FROM Master_Producto
LEFT JOIN(SELECT * FROM Producto_Estructura) AS Producto_Estructura ON ( Master_Producto.Prod_Code = Producto_Estructura.Prod_Code AND Master_Producto.Prod_PF = Producto_Estructura.Prod_PF)
LEFT JOIN(SELECT * FROM Producto_Proveedor) AS Producto_Proveedor ON ( Master_Producto.Prod_Code = Producto_Proveedor.Prod_Code AND Master_Producto.Prod_PF = Producto_Proveedor.Prod_PF)
LEFT JOIN(SELECT * FROM Producto_Precio ORDER BY Prod_DateUpd DESC) AS Producto_Precio ON ( Master_Producto.Prod_Code = Producto_Precio.Prod_Code AND Master_Producto.Prod_PF = Producto_Precio.Prod_PF)

Segunda Dúvida

o estranho é que o PHPmyadmin se me mostra os resultados completos... exibe 1 seção para cada tabela... mas não consigo fazer isso sozinho no php. Este exemplo é o resultado da execução do mesmo tubo de consulta que o recorta em imagens para que apreciem a repetição de colunas.

Instalei o PogtgreSQL versão 13 no meu laptop com sistema operacional Windows 10 e instalei o pgAdmin4.

Fiz as alterações abaixo em pg_hba.conf e pg_ident.conf para obter a autenticação SSPI. Mas recebendo a mensagem "FATAL: Falha na autenticação SSPI para o usuário "postgres" ao conectar-se ao PosgreSQL" ao conectar-se ao banco de dados

pg_hba.conf

host    all     all        127.0.0.1/32       sspi      map=SSPI
host    all     all        ::1/128            sspi      map=SSPI

pg_ident.conf

#MAPNAME        SYSTEM-USERNAME          PG-USERNAME

SSPI              admin@BEUNA-PC             admin

Arquivo de log:

2021-09-05 22:11:59.350 IST [11208] LOG:  starting PostgreSQL 13.4, compiled by Visual C++ build 1914, 64-bit
2021-09-05 22:11:59.352 IST [11208] LOG:  listening on IPv6 address "::", port 5432
2021-09-05 22:11:59.352 IST [11208] LOG:  listening on IPv4 address "0.0.0.0", port 5432
2021-09-05 22:11:59.398 IST [8948] LOG:  database system was shut down at 2021-09-05 22:11:57 IST
2021-09-05 22:11:59.424 IST [11208] LOG:  database system is ready to accept connections
2021-09-05 22:12:36.083 IST [16332] LOG:  no match in usermap "SSPI" for user "postgres" authenticated as "admin@BEUNA-PC"
2021-09-05 22:12:36.084 IST [16332] FATAL:  SSPI authentication failed for user "postgres"
2021-09-05 22:12:36.084 IST [16332] DETAIL:  Connection matched pg_hba.conf line 96: "host    all     all        ::1/128            sspi      map=SSPI"

Eu tenho uma coluna chamada "valor" na minha tabela "respostas".

|  value  |
|---------|
|  [1,2]  |
|   [1]   |
| [1,2,3] |

O tipo de "valor" é "jsonb".

Eu quero obter o valor médio de cada array em cada linha:

SELECT avg(value) AS avg_value
FROM answers

Mas isso não funciona porque avg() não é uma função jsonb. Eu tentei:

SELECT avg(value::integer[]) as avg_value
FROM answers

ou seja, tentei converter as matrizes jsonb em matrizes inteiras e, em seguida, obter o avg, mas recebo o seguinte erro: "não é possível converter o tipo jsonb para integer[]. null".

Alguma ideia?

Eu preciso de uma consulta como listar apenas todos os privilégios do sistema (não os de objeto) que são concedidos a cada usuário no banco de dados. Eu preciso de privilégios de sistema listados, sejam eles concedidos por função ou direto.

obrigada

Oi estou recebendo este erro:

Apenas uma expressão pode ser especificada na lista de seleção quando a subconsulta não é introduzida com EXISTS.

esta é minha consulta SQL atual:

DECLARE @UgpEntry VARCHAR(50)

SELECT @UgpEntry = UgpEntry FROM OITM t1 WHERE t1.ItemCode='CID-11418272385'

IF (@UgpEntry = -1)

SELECT
t1.ItemCode as sapitemcode
     , t1.CodeBars as Barcode
     , t1.ItemName as description
     ,LEFT(t1.ItemName,20) as short_description
     , 
           (select max(p.Price)
        from ITM1 p 
        where p.ItemCode = t1.ItemCode 
          and p.PriceList = 1) as [price_1]
     ,
         (SELECT T0.[ItemCode], T2.[U_NAME] as 'User that created Item', t0.updatedate

FROM AITM T0 inner join OUSR T2 on t0.usersign = t2.internal_K

WHERE T0.[ItemCode] = t1.ItemCode

group by T0.[ItemCode], T2.[U_NAME], t0.loginstanc, t0.updatedate

having t0.loginstanc = (select min(loginstanc) from AITM where itemcode = t0.loginstanc)),
     CASE t1.VatGourpSa when 'V0' THEN 4 when 'V1' THEN 1 WHEN 'V2' THEN 2 WHEN 'V3' THEN 3 END as TaxCode,t1.U_GRUPOA, t1.U_GRUPOB, t1.U_GRUPOC, t1.UgpEntry

FROM OITM t1
WHERE t1.ItemCode='CID-11418272385'
 
ELSE

SELECT t1.ItemCode as sapitemcode
     , t1.CodeBars as Barcode
     , t1.ItemName as description
     ,LEFT(t1.ItemName,20) as short_description
     , (select max(p.Price)
        from ITM9 p 
        where p.ItemCode = t1.ItemCode 
          and p.UomEntry = 1 and p.PriceList = 1) as [price_1mananitas],

           (select max(p.Price)
        from ITM1 p 
        where p.ItemCode = t1.ItemCode 
          and p.PriceList = 1) as [preciocajamananitas],
(select max(p.Price)
        from ITM9 p 
        where p.ItemCode = t1.ItemCode 
          and p.UomEntry = 1 and p.PriceList = 2) as [price_2cabra],
               (select max(p.Price)
        from ITM1 p 
        where p.ItemCode = t1.ItemCode 
          and p.PriceList = 2) as [preciocajacabra]

     , CASE t1.VatGourpSa when 'V0' THEN 4 when 'V1' THEN 1 WHEN 'V2' THEN 2 WHEN 'V3' THEN 3 END as TaxCode,t1.U_GRUPOA, t1.U_GRUPOB, t1.U_GRUPOC, t1.UgpEntry

FROM OITM t1
WHERE t1.ItemCode='CID-11418272385'

acabei de adicionar esta subconsulta:

(SELECT T0.[ItemCode], T2.[U_NAME] as 'User that created Item', t0.updatedate
    
    FROM AITM T0 inner join OUSR T2 on t0.usersign = t2.internal_K
    
    WHERE T0.[ItemCode] = t1.ItemCode
    
    group by T0.[ItemCode], T2.[U_NAME], t0.loginstanc, t0.updatedate
    
    having t0.loginstanc = (select min(loginstanc) from AITM where itemcode = t1.ItemCode))

quando eu executo isso sozinho, recebo algo assim:

o que estou tentando fazer é adicionar esse select dentro da minha consulta principal para que apareça como novas colunas dentro da consulta original. Portanto, deve aparecer como novas colunas (T2.[U_NAME] e t0.updatedate) no final assim:

o que estou faltando?

obrigada