Embora a versão de correção 3.11.17 para Cassandra 3.11.x tenha sido anunciada há algum tempo, a versão mais recente do pacote Debian no repositório oficial do Debian conforme https://apache.jfrog.io/artifactory/cassandra-deb/dists/311x /main/binary-amd64/Packages ainda é 3.11.16.
Package: cassandra
Version: 3.11.16
Existe alguma razão específica para isso?
Obrigado.
Quero que esta instrução insira os dados variáveis na minha instrução psql, mas não sei como inicializar os dados na instrução json.
INSERT INTO audit_log (
action,
result,
input_data,
output_data,
sponsor_id,
user_id)
VALUES(
1020,
1,
'{"Sponsor id": $input_sponsor_id, "User id": $input_username, "Password": $input_password}',
'{"Status": "json return?"}',
input_sponsor_id,
input_user_id);
Imagine que temos um tableusuário e um itemusuário. Essas 2 tabelas possuem uma tabela associativa chamada user_itempara definir um many to manyrelacionamento.
Começamos 100 itemregistros
Temos 500 milhões userde registros.
Portanto devemos gerar 50_000_000_000 user_item(50 bilhões)
Poderíamos potencialmente ter ainda mais
Não será fácil fragmentar nem particionar porque isso tornará qualquer outra operação mais lenta (caso contrário, precisaremos verificar tudo)
Assuma como padrão de consulta ( INSERT, SELECT, UPDATE) padrões m2m básicos/típicos (que podem ser encontrados em qualquer tutorial ou exemplo
Qual é o melhor design ou solução conhecida para lidar com bilhões de relacionamentos Muitos para Muitos em um banco de dados, independentemente de um esquema?
Imagine este esquema simples
CREATE DATABASE IF NOT EXISTS `playground` CHARACTER SET = latin1;
USE playground;
CREATE TABLE IF NOT EXISTS `user`
(
`id` BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
`name` VARCHAR(255) NOT NULL,
PRIMARY KEY (`id`),
INDEX `user__name_fk` (`name`)
) ENGINE = InnoDB
DEFAULT CHARSET = latin1
ROW_FORMAT = DYNAMIC;
CREATE TABLE IF NOT EXISTS `item`
(
`id` BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
`name` VARCHAR(255) NOT NULL,
PRIMARY KEY (`id`),
INDEX `user__name` (`name`)
) ENGINE = InnoDB
DEFAULT CHARSET = latin1
ROW_FORMAT = DYNAMIC;
CREATE TABLE IF NOT EXISTS `user_item`
(
`user_id` BIGINT UNSIGNED NOT NULL,
`item_id` BIGINT UNSIGNED NOT NULL,
PRIMARY KEY (`user_id`, `item_id`),
INDEX `user_item__item` (`item_id`),
FOREIGN KEY `user_id_fk` (`user_id`) REFERENCES `user` (`id`) ON DELETE CASCADE,
FOREIGN KEY `item_id_fk` (`item_id`) REFERENCES `item` (`id`) ON DELETE CASCADE
) ENGINE = InnoDB
DEFAULT CHARSET = latin1
ROW_FORMAT = DYNAMIC;
-- create some default items
INSERT INTO `item` (`name`) VALUES ('item_1'), ('item_2'), ('item_3'), ('item_4'), ('item_5'), ('item_6'), ('item_7'), ('item_8'), ('item_9'), ('item_10');
-- create some users
INSERT INTO `user` (`name`) VALUES ('user_1'), ('user_2'), ('user_3'), ('user_4'), ('user_5'), ('user_6'), ('user_7'), ('user_8'), ('user_9'), ('user_10');
INSERT INTO `user_item` (`user_id`, `item_id`) VALUES (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (1, 10);
Não estou perguntando como usar o relacionamento muitos para muitos no MySQL, eu sei disso. Estou perguntando qual é a solução mais conhecida para um problema de escala, ou seja, quando o número de registros relacionados está crescendo exponencialmente em uma escala tão grande.
Além disso, intencionalmente não adicionei nenhum padrão de consulta ( INSERT, SELECT, UPDATE) porque é irrelevante . Suponha o padrão M2M mais típico. Não quero perder o foco na questão real que é sobre escalabilidade e enorme quantidade de dados.
Deve haver algum truque ou alguma solução alternativa conhecida, certo? Também estou considerando um banco de dados NoSQL, então a resposta pode incluir qualquer coisa não relacionada ao MySQL (ou qualquer banco de dados SQL),
Sinto que este deveria ser um problema comum que muitas grandes empresas enfrentarão e, portanto, deveria haver uma solução comum (ou poucas). A causa raiz desse problema é que, embora o MySQL seja ótimo para criar relacionamentos, ele aumentará exponencialmente a tabela associativa m2m .
Os 500 milhões x 100 == 50 bilhões são apenas um exemplo. Mas poderia teoricamente acontecer.
Aqui está um exemplo de uma consulta simples de muitos para muitos.
SELECT user.*, item.* FROM user
LEFT JOIN user_item ON user.id = user_item.user_id
LEFT JOIN item ON item.id = user_item.item_id
WHERE user.name = 'user_1';
Perguntas semelhantes, mas não iguais
estou procurando as melhores práticas para sincronizar meu banco de dados hospedado com meu banco de dados local, para servir como banco de dados de backup e de emergência!
Preciso de conselhos sobre a melhor solução que considere velocidade e eficiência, sem passar por todos os dados e minimizar a carga visando apenas as atualizações
eu tenho banco de dados mysql hospedado no hostgator
Repetidamente me deparo com esse problema em que edito algum arquivo de configuração do cassandra e o serviço cassandra não inicia mais.
Como posso entender por que service cassandra start o Cassandra não inicia? Se eu executar, /etc/init.d/cassandraele começa bem.
journalctl -u cassandra.servicenão tem nenhum registro.
/var/log/cassandra/system.log, /var/log/cassandra/debug.log, /var/log/syslogtambém não tem registros.
Quando executo service cassandra statuso status é "ativo (saiu)"
Eu tenho a versão mais recente do cassandra instalada apt-getno debian.
Eu tenho um arquivo .mdf de 120 GB. Ele deveria conter um procedimento armazenado que era apenas para um protótipo e, portanto, foi removido quando corrigimos o banco de dados com novos procedimentos.
Gostaria de recuperá-lo, mas não consigo anexar o banco de dados ao meu banco de dados local, pois não tenho licença para isso. Quando tento conectá-lo ao servidor, ele reclamará que já existe um banco de dados com esse nome e não quero desconectar o servidor porque ele está sendo usado no momento.
Existe uma maneira de usar algum comando cmd, ou igual, para extrair o script SQL do arquivo?
Eu tenho um pacote SSIS que está funcionando perfeitamente no meu servidor. Sempre que eu o abro no Visual Studio, "Work Offline" é ativado para duas das conexões SQL. Isso produz mais de 100 erros no código que sei estar funcionando perfeitamente. O referido código tem múltiplas conexões e são apenas essas duas que apresentam o problema. Os dois com o problema se comportam de maneira diferente:
Não vou perguntar como consertar isso, pois é claramente algo mágico. Em vez disso, minha pergunta é esta: como começo a depurar esse problema?
Estou procurando maneiras de melhorar o desempenho do meu banco de dados para consultas analíticas pesadas e descobri que meu espaço de tabela temporário tem extensões de 1 milhão (padrão para espaço de tabela uniforme). Com meu uso normal de espaço de tabela temporário muito acima de 1 GB por consulta (as principais consultas com junções/classificações/grupos pesados podem consumir até 100 GB de espaço de tabela temporário), extensões de 1 milhão parecem muito baixas para mim. Vale a pena aumentar o tamanho da extensão para desempenho?
Estou ajustando uma consulta que está lenta, reduzi a raiz do problema para estar bem no início do plano de execução, onde o SQL Server faz uma estimativa incorreta em um filtro WHERE IS NULL que suporta uma anti-junção à esquerda - SQL O servidor estima 1 linha e favorece algumas varreduras de índice através de um loop aninhado, pensando que só as executará uma vez, quando na verdade isso acontece milhares de vezes:
Consegui criar um MCVE para replicar o problema.
Configurar o ambiente de teste
/* INSERT 35000 dinstinct random numbers into a table */
CREATE TABLE #TableA
(
ID BIGINT NULL
)
INSERT INTO #TableA
SELECT DISTINCT
TOP 35000
a.Random
FROM (
SELECT TOP 50000
ABS(CHECKSUM(NewId())) % 20000000 AS Random
FROM sys.messages
) a
GO
/* add a further 15000 that already exist in the table. Use a loop to increase the possibility of duplicates */
INSERT INTO #TableA
SELECT TOP 1000
ID
FROM #TableA a
ORDER BY NEWID()
GO 15
/* Insert 10000 numbers into another table, that are in the first table */
CREATE TABLE #TableB
(
ID BIGINT NOT NULL
)
INSERT INTO #TableB
SELECT TOP 10000
*
FROM #TableA
/* insert 80000 distinct random numbers that are not in the first table */
INSERT INTO #TableB
SELECT DISTINCT
TOP 80000
a.Random
FROM (
SELECT TOP 100000
ABS(CHECKSUM(NewId())) % 2000000 AS Random
FROM sys.messages
) a
LEFT JOIN #TableA b
ON a.Random = b.ID
WHERE b.ID IS NULL
Então, a consulta que sofre o problema é
SELECT a.ID
FROM #TableA a
LEFT JOIN #TableB b
ON a.ID = b.ID
WHERE b.ID IS NULL
O que é bastante simples "mostre-me todos os IDs na Tabela A que não estão na Tabela B"
O plano de execução do meu ambiente de teste está aqui
Podemos ver algo muito semelhante acontecendo como vemos no plano acima, em termos do operador de filtro - o SQL Server une as duas tabelas e depois filtra os registros que estão na tabela da esquerda, mas não na tabela da direita e isso subestima enormemente o número de linhas que correspondem a esse predicado
Se eu forçar a estimativa herdada, obterei uma estimativa muito melhor do operador
Acredito que uma das principais diferenças entre o estimador antigo e os novos estimadores é como eles diferem na suposição da correlação entre dois predicados - o antigo assume que há pouca correlação entre dois predicados, enquanto o novo estimador é mais otimista e assume uma maior correlação?
Minhas perguntas são
Estou usando o MySQL versão 8.3.0.
Posso criar um relacionamento “muitos para muitos” entre tabelas de pessoas e equipes com as seguintes instruções SQL:
create table persons (
id bigint not null,
last_name varchar(255) not null,
first_name varchar(255),
primary key (id)
);
create table teams (
id bigint not null,
team_name varchar(255) not null,
primary key (id)
);
create table person_team (
person_id bigint not null,
team_id bigint not null,
primary key (person_id, team_id),
constraint fk_person_team_person foreign key (person_id) references persons(id),
constraint fk_person_team_team foreign key (team_id) references teams(id)
);
Portanto, a person_teamtabela possui uma chave primária composta e cada uma de suas colunas é uma chave estrangeira para as tabelas às quais ela une.
Se eu recuperar a instrução DDL para person_teamwith show create table person_team;, isso me dará o seguinte SQL:
CREATE TABLE `person_team` (
`person_id` bigint NOT NULL,
`team_id` bigint NOT NULL,
PRIMARY KEY (`person_id`,`team_id`),
KEY `fk_person_team_team` (`team_id`),
CONSTRAINT `fk_person_team_person` FOREIGN KEY (`person_id`) REFERENCES `persons` (`id`),
CONSTRAINT `fk_person_team_team` FOREIGN KEY (`team_id`) REFERENCES `teams` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci
Assim, ele adiciona automaticamente uma KEYinstrução (linha 5) com o nome chave estrangeira à teamstabela.
Por que esse comportamento? Esta KEYinstrução extra não parece necessária para mim. Por que mostra uma chave para fk_person_team_teame não para fk_person_team_person? A afirmação inicial está errada ou incompleta? O DDL gerado automaticamente está correto? Quando despejo meu banco de dados com mysqldump, obtenho o mesmo código do DDL gerado automaticamente. É mais seguro modificar este código para restaurar o banco de dados?