Digamos que uma tabela cartenha um relacionamento um para um com tabelas electric_car, gas_care hybrid_car. Se a carfor electric_car, não poderá mais aparecer em gas_carou a hybrid_car, etc.
Há algo de errado com esse design? Alguns problemas que podem ocorrer no caminho?
Eu só quero saber como instalar o módulopg_tgrm usado no esquema de indexação de trigramas que permite fazer padrões de pesquisa não ancorados em um índice.
WHERE foo LIKE '%bar%';
Digamos que eu tenha o seguinte esquema e dados:
create table images(
id int not null
);
insert into images values(1), (2), (3), (4), (6), (8);
Eu quero realizar uma consulta como:
select id from images where id not exists in(4, 5, 6);
Mas isso não funciona. O caso acima deve retornar 5, pois não existe nos registros da tabela.
Estou trabalhando com o SQL Server 2012. Quero verificar se existe um usuário antes de adicioná-lo a um banco de dados.
Isto é o que eu testei:
USE [MyDatabase]
GO
IF NOT EXISTS (SELECT name
FROM [sys].[server_principals]
WHERE name = N'IIS APPPOOL\MyWebApi AppPool')
Begin
CREATE USER [IIS APPPOOL\MyWebApi AppPool]
FOR LOGIN [IIS APPPOOL\MyWebApi AppPool] WITH DEFAULT_SCHEMA=[dbo]
end
ALTER ROLE [db_owner] ADD MEMBER [IIS APPPOOL\MyWebApi AppPool]
GO
Mas esse código SELECT name FROM [sys].[server_principals]não retorna se esse usuário existir no MyDatabase.
Como posso verificar se um usuário existe em MyDatabase?
Usando MySQL 5.6 com mecanismo de armazenamento InnoDB para a maioria das tabelas. O tamanho do buffer pool do InnoDB é de 15 GB e os índices do Innodb DB + são de cerca de 10 GB. O servidor tem 32 GB de RAM e está executando o Cent OS 7 x64.
Eu tenho uma grande tabela que contém cerca de 10 milhões + registros.
Recebo um arquivo de despejo atualizado de um servidor remoto a cada 24 horas. O arquivo está no formato csv. Eu não tenho controle sobre esse formato. O arquivo tem ~ 750 MB. Eu tentei inserir dados em uma tabela MyISAM linha por linha e levou 35 minutos.
Eu preciso pegar apenas 3 valores por linha de 10-12 do arquivo e atualizá-lo no banco de dados.
Qual é a melhor maneira de conseguir algo assim?
Eu preciso fazer isso diariamente.
Atualmente o Flow está assim:
As operações acima levam cerca de 30 a 40 minutos para serem concluídas e, ao fazer isso, há outras atualizações em andamento, o que me dá
Tempo limite de espera de bloqueio excedido; tente reiniciar a transação
carregamento de dados em nova tabela usando LOAD DATA LOCAL INFILE. No MyISAM demorou 38.93 secenquanto no InnoDB demorou 7 min 5,21 seg. Então eu fiz:
UPDATE table1 t1, table2 t2
SET
t1.field1 = t2.field1,
t1.field2 = t2.field2,
t1.field3 = t2.field3
WHERE t1.field10 = t2.field10
Query OK, 434914 rows affected (22 hours 14 min 47.55 sec)
mesma atualização com consulta de junção
UPDATE table1 a JOIN table2 b
ON a.field1 = b.field1
SET
a.field2 = b.field2,
a.field3 = b.field3,
a.field4 = b.field4
(14 hours 56 min 46.85 sec)
Esclarecimentos de perguntas nos comentários:
Atualização 3:
aqui estão mais detalhes sobre ambas as tabelas.
CREATE TABLE `content` (
`hash` char(40) CHARACTER SET ascii NOT NULL DEFAULT '',
`title` varchar(255) COLLATE utf8_unicode_ci NOT NULL DEFAULT '',
`og_name` varchar(255) COLLATE utf8_unicode_ci NOT NULL DEFAULT '',
`keywords` varchar(255) COLLATE utf8_unicode_ci NOT NULL DEFAULT '',
`files_count` smallint(5) unsigned NOT NULL DEFAULT '0',
`more_files` smallint(5) unsigned NOT NULL DEFAULT '0',
`files` varchar(255) COLLATE utf8_unicode_ci NOT NULL DEFAULT '0',
`category` smallint(3) unsigned NOT NULL DEFAULT '600',
`size` bigint(19) unsigned NOT NULL DEFAULT '0',
`downloaders` int(11) NOT NULL DEFAULT '0',
`completed` int(11) NOT NULL DEFAULT '0',
`uploaders` int(11) NOT NULL DEFAULT '0',
`creation_date` datetime NOT NULL DEFAULT '0000-00-00 00:00:00',
`upload_date` datetime NOT NULL DEFAULT '0000-00-00 00:00:00',
`last_updated` datetime NOT NULL DEFAULT '0000-00-00 00:00:00',
`vote_up` int(11) unsigned NOT NULL DEFAULT '0',
`vote_down` int(11) unsigned NOT NULL DEFAULT '0',
`comments_count` int(11) NOT NULL DEFAULT '0',
`imdb` int(8) unsigned NOT NULL DEFAULT '0',
`video_sample` tinyint(1) NOT NULL DEFAULT '0',
`video_quality` tinyint(2) NOT NULL DEFAULT '0',
`audio_lang` varchar(127) CHARACTER SET ascii NOT NULL DEFAULT '',
`subtitle_lang` varchar(127) CHARACTER SET ascii NOT NULL DEFAULT '',
`verified` tinyint(1) unsigned NOT NULL DEFAULT '0',
`uploader` int(11) unsigned NOT NULL DEFAULT '0',
`anonymous` tinyint(1) NOT NULL DEFAULT '0',
`enabled` tinyint(1) unsigned NOT NULL DEFAULT '0',
`tfile_size` int(11) unsigned NOT NULL DEFAULT '0',
`scrape_source` tinyint(1) unsigned NOT NULL DEFAULT '0',
`record_num` int(11) unsigned NOT NULL AUTO_INCREMENT,
PRIMARY KEY (`record_num`),
UNIQUE KEY `hash` (`hash`),
KEY `uploaders` (`uploaders`),
KEY `tfile_size` (`tfile_size`),
KEY `enabled_category_upload_date_verified_` (`enabled`,`category`,`upload_date`,`verified`),
KEY `enabled_upload_date_verified_` (`enabled`,`upload_date`,`verified`),
KEY `enabled_category_verified_` (`enabled`,`category`,`verified`),
KEY `enabled_verified_` (`enabled`,`verified`),
KEY `enabled_uploader_` (`enabled`,`uploader`),
KEY `anonymous_uploader_` (`anonymous`,`uploader`),
KEY `enabled_uploaders_upload_date_` (`enabled`,`uploaders`,`upload_date`),
KEY `enabled_verified_category` (`enabled`,`verified`,`category`),
KEY `verified_enabled_category` (`verified`,`enabled`,`category`)
) ENGINE=InnoDB AUTO_INCREMENT=7551163 DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci ROW_FORMAT=FIXED
CREATE TABLE `content_csv_dump_temp` (
`hash` char(40) CHARACTER SET ascii NOT NULL DEFAULT '',
`title` varchar(255) COLLATE utf8_unicode_ci NOT NULL,
`category_id` int(11) unsigned NOT NULL DEFAULT '0',
`uploaders` int(11) unsigned NOT NULL DEFAULT '0',
`downloaders` int(11) unsigned NOT NULL DEFAULT '0',
`verified` tinyint(1) unsigned NOT NULL DEFAULT '0',
PRIMARY KEY (`hash`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci
e aqui está a consulta de atualização que atualiza contenta tabela usando dados decontent_csv_dump_temp
UPDATE content a JOIN content_csv_dump_temp b
ON a.hash = b.hash
SET
a.uploaders = b.uploaders,
a.downloaders = b.downloaders,
a.verified = b.verified
atualização 4:
todos os testes acima foram feitos na máquina de teste., mas agora fiz os mesmos testes na máquina de produção, e as consultas são muito rápidas.
mysql> UPDATE content_test a JOIN content_csv_dump_temp b
-> ON a.hash = b.hash
-> SET
-> a.uploaders = b.uploaders,
-> a.downloaders = b.downloaders,
-> a.verified = b.verified;
Query OK, 2673528 rows affected (7 min 50.42 sec)
Rows matched: 7044818 Changed: 2673528 Warnings: 0
Eu peço desculpas pelo meu erro. É melhor usar join em vez de cada atualização de registro. agora estou tentando melhorar o mpre usando o índice sugerido por rick_james , será atualizado assim que o benchmarking for feito.
Estamos projetando um sistema que é conhecido por ser de leitura pesada (da ordem de dezenas de milhares de leituras por minuto).
namesque serve como uma espécie de registro central. Cada linha tem um textcampo representatione um exclusivo keyque é um hash MD5 daquele representation. 1 Esta tabela tem atualmente dezenas de milhões de registros e espera-se que cresça em bilhões ao longo da vida útil do aplicativo.namestabela. Qualquer registro em uma dessas tabelas tem a garantia de ter um name_key, que é funcionalmente uma chave estrangeira para a namestabela.1: Aliás, como você pode esperar, os registros nesta tabela são imutáveis uma vez gravados.
Para qualquer tabela que não seja a namestabela, a consulta mais comum seguirá este padrão:
SELECT list, of, fields
FROM table
WHERE name_key IN (md5a, md5b, md5c...);
Eu gostaria de otimizar o desempenho de leitura. Suspeito que minha primeira parada deve ser minimizar o tamanho dos índices (embora eu não me importe de ser provado errado lá).
A pergunta:
Qual é/são os tipos de dados ideais para as colunas keye ?
Existe uma razão para usar mais ? ou ?name_keyhex(32)bit(128)BTREEGIN
Eu tenho um zoológico de 20 milhões de animais que acompanho em meu banco de dados SQL Server 2005. Cerca de 1% deles são negros e cerca de 1% deles são cisnes. Eu queria obter detalhes de todos os cisnes negros e assim, não querendo inundar a página de resultados, fiz:
select top 10 *
from animal
where colour like 'black'
and species like 'swan'
(Sim, desaconselhadamente esses campos são de texto livre, mas ambos são indexados). Acontece que não temos esses animais, pois a consulta retorna um conjunto vazio em cerca de 300 milissegundos. Teria sido cerca de duas vezes mais rápido se eu tivesse usado '=' em vez de 'curtir', mas tenho uma premonição de que o último está prestes a me poupar um pouco de digitação.
Acontece que o tratador-chefe acha que ele pode ter inserido alguns dos cisnes como 'negros', então modifico a consulta de acordo:
select top 10 *
from animal
where colour like 'black%'
and species like 'swan'
Acontece que também não há nenhum desses (e de fato não há animais 'black%', exceto os 'black'), mas a consulta agora leva cerca de 30 segundos para retornar vazia.
Parece que é apenas a combinação de 'top' e 'like %' causando problemas porque
select count(*)
from animal
where colour like 'black%'
and species like 'swan'
retorna 0 muito rapidamente, e mesmo
select *
from animal
where colour like 'black%'
and species like 'swan'
retorna vazio em uma fração de segundo.
Alguém tem alguma ideia de por que 'top' e '%' devem conspirar para causar uma perda tão dramática de desempenho, especialmente em um conjunto de resultados vazio?
EDIT: Só para esclarecer, não estou usando nenhum índice FreeText, apenas quis dizer que os campos são de texto livre no ponto de entrada, ou seja, não normalizados no banco de dados. Desculpe a confusão, palavras mal formuladas da minha parte.
Muitas vezes preciso escrever algo como o seguinte ao lidar com o SQL Server.
create table #table_name
(
column1 int,
column2 varchar(200)
...
)
insert into #table_name
execute some_stored_procedure;
Mas criar uma tabela que tenha a sintaxe exata como resultado de um procedimento armazenado é uma tarefa tediosa. Por exemplo, o resultado de sp_helppublication tem 48 colunas! Gostaria de saber se existe alguma maneira fácil de fazer isso.
Obrigado.
Portanto, um comentário desta pergunta menciona que há uma pequena diferença em "Procedimentos armazenados" e "Funções armazenadas" no PostgreSQL.
O comentário tem links para um artigo da wikipedia, mas alguns deles não parecem se aplicar (por exemplo, que podem ser usados em uma SELECTdeclaração).
A sintaxe em si parece ser um pouco confusa:
CREATE FUNCTION emp_stamp() RETURNS trigger AS $emp_stamp$
BEGIN
[...]
END;
$emp_stamp$ LANGUAGE plpgsql;
CREATE TRIGGER emp_stamp BEFORE INSERT OR UPDATE ON emp
FOR EACH ROW EXECUTE PROCEDURE emp_stamp();
Você cria um FUNCTIONmas se refere a ele como um PROCEDURE.
Então, qual é a diferença entre esses dois?
No SQL Server (2008 neste caso), como posso reduzir rapidamente todos os arquivos, log e dados, para todos os bancos de dados em uma instância? Eu poderia passar pelo SSMS e clicar com o botão direito em cada um e escolher Tarefas -> Encolher, mas estou procurando algo mais rápido.
Eu criei scripts de alguns scripts "Criar banco de dados" e esqueci que eles tinham tamanhos de balão para padrões e não precisam de muito espaço reservado para esses arquivos neste projeto.