Eu tentei-->
UPDATE tbl AS r
INNER JOIN tbl AS f ON r.columnA = f.columnA
SET r.columnB = f.columnB, r.columnC = f.columnC
WHERE f.columnA = r.columnA
tbl como nome da tabela
antes
| EU IA | colunaA | colunaB | colunaC |
|---|---|---|---|
| 1 | 1 | dados1 | |
| 2 | 1 | dados2 | |
| 3 | 2 | dados3 | |
| 4 | 2 | dados4 |
depois
| EU IA | colunaA | colunaB | colunaC |
|---|---|---|---|
| 2 | 1 | dados2 | dados1 |
| 4 | 2 | dados4 | dados3 |
Sou um estudante que aprendeu sobre banco de dados teoricamente, não na prática.
Mas agora tenho a chance de projetar um banco de dados enquanto faço esse pequeno projeto de brinquedo em equipe.
Aqui está um diagrama (omitido 1:1, 1:n, n:m) conforme abaixo:
E aqui está a descrição sobre tabelas:
Esta tabela contém informações sobre teatro. Um teatro pode ter muitos espetáculos.
Esta tabela contém informações sobre assento.
O assento pode ser diferenciado pelo par de chaves primárias: (theater_no, seat_no)
Esta tabela contém informações sobre show.
Um teatro pode ter muitos espetáculos. Mas o espetáculo acontecerá em apenas um teatro.
(Portanto, o Teatro depende do Show. Podemos escolher o Teatro adequado automaticamente após selecionar Show.)
Esta tabela contém classificações de assento para cada assento. Esta é uma tabela de mapeamento entre 'assento' e 'show' porque um mesmo assento pode ter graus diferentes para shows diferentes.
[Aqui está um exemplo : ]
'Show 1', 'Show 2' acontecem no mesmo Teatro, 'Teatro 1' e 'Teatro 1' têm 'Assento 1'
Então, 'Assento 1' é grau A para 'Show 1' e 'Assento 1' é grau C para 'Show 2'.
Esta tabela contém informações sobre o usuário.
Esta tabela contém informações sobre avaliações.
Esta tabela contém informações sobre avaliações de assentos.
Esta tabela contém informações sobre avaliações do show.
Lógica de serviço:
Aplicativo de logins de usuário, uma lista de páginas principal é exibida.
Se o usuário selecionar um show, lista a sede do teatro (onde o show escolhido aconteceu).
Se o usuário selecionar um assento, será exibida uma avaliação sobre o assento (mas a avaliação também depende do show).
O '3' é um problema principal para mim, porque é difícil projetar uma tabela de 'avaliações', pois depende não apenas do show, mas também do assento.
No início, projetei a tabela 'reviews' com 4 chaves primárias: (user_id, show_no, theater_no, seat_no) sem a tabela 'seat_review' e a tabela 'show_review'.
Mas achei que isso era muito confuso, então mudei o design como acima.
Ainda estou confuso sobre esse design, não tenho certeza se isso preservará a integridade dos dados, a velocidade de processamento, etc.
Então, minha principal dúvida é:
Existe alguma boa ideia para criar uma mesa de 'revisão'? (parece (muitos-para-muitos)-para-muitos (?) para mim.)
Para as 4 tabelas da esquerda ('theater', 'seat', 'seat_show_grade', 'show') tem relação cíclica. Esse design é ruim para banco de dados? Se estiver ruim, como posso mudar isso?
Obrigado pela ajuda.
Anexado:
A ideia anterior de usar tabela de mapeamento.
(O que eu disse são 4 chaves primárias, sem 'seat_review' e 'show_review')
Uma tabela tem a seguinte estrutura:
Olhando as estatísticas em 2 semanas, veja muitas atualizações:
dapenas o campo (tempo total: 25 minutos medidos no aplicativo)Como o Postgres segue o padrão MVCC que reescreve as linhas na atualização, é interessante alterar a estrutura da tabela para ter duma tabela separada?
Suponhamos que existam 100 tipos de cães espalhados pelos documentos da minha coleção. Se eu preciso agrupar por tipos de cães e depois calcular algumas estatísticas agregadas sobre cada tipo de cão, por que realizar uma consulta envolvendo , $groupque em princípio processa cada documento sequencialmente, em vez de enviar 100 consultas separadas e simultâneas ao banco de dados onde cada consulta é filtrada com base sobre o tipo de cachorro?
As 100 consultas simultâneas e separadas não seriam mais rápidas?
Se for mais rápido, em escala, qual é a desvantagem de não fazê-lo, se houver?
Eu tenho a seguinte tabela
CREATE TABLE `books` (
`book_id` int(11) NOT NULL AUTO_INCREMENT,
`title` varchar(100) DEFAULT NULL,
`author_fname` varchar(100) DEFAULT NULL,
`author_lname` varchar(100) DEFAULT NULL,
`released_year` int(11) DEFAULT NULL,
`stock_quantity` int(11) DEFAULT NULL,
`pages` int(11) DEFAULT NULL,
PRIMARY KEY (`book_id`)
)
Tentando descobrir o ano de lançamento do primeiro e último livro do autor apenas para autores que possuem mais de um livro. A seguir está a consulta
SELECT author_lname,
MIN(released_year) first_release,
MAX(released_year) last_release,
COUNT(*) book_count,
MAX(pages) max_page_count
FROM books
GROUP BY author_lname
ORDER BY book_count DESC;
Mas não posso usar a cláusula book_countin where, então posso fazer. book_count > 1
Estou procurando uma explicação de por que isso não é possível e como obter o resultado esperado.
Foi-nos atribuído um novo aplicativo em que o fornecedor espera que o banco de dados cresça para cerca de 100 TB. Eles mencionaram que o SQL Server Standard Edition é compatível.
Minha pergunta é se o SQL Server Standard Edition pode lidar adequadamente com um banco de dados desse tamanho?
A Enterprise Edition pode lidar com a reconstrução de índices online, mas no geral o SQL Server pode lidar com um banco de dados tão grande?
O maior banco de dados que gerenciei tem 3 TB e estou preocupado com o desempenho de um banco de dados de 100 TB com o SQL Server 2019.
Quaisquer conselhos de especialistas serão muito apreciados.
Tenho uma pergunta relacionada a um incidente que aconteceu em um de nossos bancos de dados Postgres.
Temos um serviço backend que monitora a atividade do usuário em algum tipo de evento online. O serviço utiliza o Postgres 12 como banco de dados, e para esse tipo de evento existe uma tabela (chamarei user_eventno restante da pergunta) onde os dados são mantidos. A tabela tinha cerca de 3.500 transações por segundo, principalmente atualizações (das quais quase todas eram atualizações HOT - isso pode ser uma parte importante).
Aqui está um gráfico separado para tuplas inseridas e excluídas (as excluídas são 0), pois não é visível na foto acima:
O número de tuplas ativas aumentou assim:
O uso da tabela começou em aproximadamente 11 e estava indo bem durante o dia, mas por volta das 18h o tamanho da tabela passou de aproximadamente 3 GB para> 80 GB em 2 horas. Isso fez com que o disco quase atingisse sua capacidade total, então tivemos que desabilitar o evento em andamento e fazer um vácuo completo, o que reduziu o tamanho da tabela de >80GB para ~3GB.
Aqui está o tamanho da tabela com estimativas de inchaço:
* calculamos o inchaço exibido no segundo gráfico com esta consulta
Os índices das tabelas não cresceram tanto:
Naquele momento (por volta das 20h30 - 21h), suspeitamos que o problema era o autovacuum e que precisava ser mais agressivo, então configuramos o tempo de soneca de 30s (o padrão é 1 min) e definimos para 0,005 e para 0 (os últimos autovacuum_vacuum_scale_factor2 autovacuum_vacuum_cost_delayparâmetros definimos apenas para a tabela crítica). Antes dessas mudanças, o autovacuum era executado uma vez a cada 60s antes das 18h e depois das 18h uma vez a cada 2min (devido ao crescimento da tabela).
Talvez uma informação importante seja que durante todo o evento, a grande maioria dos checkpoints foram solicitados (não cronometrados) com frequência de uma vez a cada 3-4 minutos:
Depois disso, o problema não se repetiu, mas ainda não conseguimos explicar por que e como aconteceu esse grande aumento no tamanho da tabela. Após uma inspeção detalhada, o autovacuum (e a autoanalyse) funcionou o tempo todo na mesa (confirmamos isso em métricas e logs).
Para lhe dar mais contexto, notamos uma mudança na dinâmica dos buffers quando a tabela começou a aumentar rapidamente (por volta das 18h):
Alguém tem uma ideia do que/onde procurar para explicar isso? Se precisar de mais informações, posso fornecê-las.
Dados adicionais: o esquema da tabela user_event é este:
# \d user_event;
Table "public.user_event"
Column | Type | Collation | Nullable | Default
----------------------------------+--------------------------+-----------+----------+---------
id | uuid | | not null |
event_id | text | | not null |
user_id | bigint | | not null |
server_id | integer | | not null |
state | text | | not null |
generator_type | text | | |
timestamp_when_claimable | timestamp with time zone | | not null |
claimeditems | jsonb | | not null |
timestamp_when_energy_full | timestamp with time zone | | not null |
overflow_energy | integer | | not null |
timestamp_when_energy_cost_reset | timestamp with time zone | | not null |
grid | jsonb | | not null |
refill_count | integer | | not null |
Indexes:
"user_event_pkey" PRIMARY KEY, btree (id)
"idx_event_id" btree (event_id)
"idx_event_id_state" btree (event_id, state)
"idx_login_id" btree (login_id)
"idx_login_id_event_id" btree (login_id, event_id)
A versão do Postgres é 12, com os parâmetros mais importantes:
Os recursos da VM são:
Digamos que tenho esta consulta:
DECLARE @QueryString NVARCHAR(MAX) ;
SELECT @QueryString = COALESCE(@QueryString + ' UNION ALL ','')
+ 'SELECT '
+ '''' + QUOTENAME(SCHEMA_NAME(sOBJ.schema_id))
+ '.' + QUOTENAME(sOBJ.name) + '''' + ' AS [TableName]
, COUNT(*) AS [RowCount] FROM '
+ QUOTENAME(SCHEMA_NAME(sOBJ.schema_id))
+ '.' + QUOTENAME(sOBJ.name) + ' WITH (NOLOCK) '
FROM sys.objects AS sOBJ
WHERE
sOBJ.type = 'U'
AND sOBJ.is_ms_shipped = 0x0
ORDER BY SCHEMA_NAME(sOBJ.schema_id), sOBJ.name ;
EXEC sp_executesql @QueryString
GO
que extraem todas as tabelas de um banco de dados e o número de registros em cada tabela.
A pergunta é bem fácil, mas não consigo descobrir como fazer :) Como posso fazer o pedido por TableName? Ou RowCount?
Colocá-lo em ordem por cláusula me dá um erro (ou seja, sintaxe incorreta perto de 'SCHEMA_NAME'. ).
Obrigado por qualquer dica sofisticada.
Estou usando o MySQL 8.0 (dentro do Banco de Dados do Azure para MySQL Server).
Notei um comportamento estranho ao consultar a funcionalidade "json_extract". No exemplo abaixo, estou consultando um campo VARCHAR que contém o texto JSON válido: {"myfield":"123456"}.
SELECT json_extract(jsontext, '$.myfield') raw_extract,
LENGTH(json_extract(jsontext, '$.myfield')) raw_extract_length,
CASE WHEN json_extract(jsontext, '$.myfield') = '123456' THEN 'true' ELSE 'false' END matches_no_quotes,
CASE WHEN json_extract(jsontext, '$.myfield') = '"123456"' THEN 'true' ELSE 'false' END matches_with_quotes,
CASE WHEN json_extract(jsontext, '$.myfield') LIKE '"%"' THEN 'true' ELSE 'false' END matches_wildcard_dbl_quotes
O que é estranho é que o valor retornado por json_extract parece se comportar de maneira diferente dependendo de qual comparação está interagindo com ele:
Como você pode ver, há basicamente dois valores de retorno: um com aspas duplas incluídas e outro sem. LENGTH(), o valor de retorno imediato e os operadores LIKE agem como se existissem aspas duplas. A igualdade (=) não funciona como se as aspas existissem.
Minha melhor teoria é que o tipo de retorno direto não é VARCHAR e, em vez disso, é algum tipo de tipo de dados JSON, mas a documentação do MySQL não confirmou ou negou isso. Como alguém que se depara com isso pela primeira vez, esse comportamento contraditório é muito confuso. Alguém pode lançar alguma luz sobre isso?
No passado : quando tive o erro ORA-00257: Archiver error, resolvi-o usando o comando RMAN:
rman target sys/1234
delete archivelog all;
Desta vez , quando tento me conectar ao destino rman :
rman target sys/1234
Eu recebo o erro:
RMAN-00554: initialization of internal recovery manager packagefailed.
RMAN-04005: error from target database.
ORA-28001:the password has expired.
Quando tento me conectar com o sqlplus como sys SYSDBA , gera o seguinte erro: ERRO:
ORA-28001: the password has expired
Changing password for SYS
New password:
Quando digito a nova senha , o erro que aparece é:
ORA-00257: Archiver error. Connect AS SYSDBA only until resolved.
Então o problema é que..
Como posso resolver isso?